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 = p.x - c.x;
            double dy = p.y - c.y;

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

            Point2D.Double c2 = new Point2D.Double(CX - dx1, CY - dy1);
            // 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.util.Scanner;

public class C465 {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double r = input.nextInt();
		double x1 = input.nextInt();
		double y1 = input.nextInt();
		double x2 = input.nextInt();
		double y2 = input.nextInt();
		double xdist = x1 - x2;
		double ydist = y1 - y2;
		double dist2 = xdist * xdist + ydist * ydist;
		if (dist2 > r * r){
			System.out.println(x1 + " " + y1 + " " + r);
		}else{
			double dist = Math.sqrt(dist2);
			double m = (dist + r) / 2;
			double x = x2 + xdist / dist * m;
			double y = y2 + ydist / dist * m;
			System.out.println(x + " " + y + " " + m);
		}
	}

}


import java.util.Scanner;

public class C465 {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double r = input.nextInt();
		double x1 = input.nextInt();
		double y1 = input.nextInt();
		double x2 = input.nextInt();
		double y2 = input.nextInt();
		if (distance2(x1, y1, x2, y2) >= r * r){
			System.out.println(x1 + " " + y1 + " " + r);
		}else{
			double d = (r + Math.sqrt(distance2(x1, y1, x2, y2))) / 2;
			double x = (x1 - x2) / Math.abs(x1 - x2) * prop(x1, y1, x2, y2) * d + x2;
			double y = (y1 - y2) / Math.abs(y1 - y2) * prop(y1, x1, y2, x2) * d + y2;
			System.out.println(x + " " + y + " " + d);
		}
	}

	public static double prop(double x1, double y1, double x2, double y2){
		return (x2 - x1)  / Math.sqrt(distance2(x1, y1, x2, y2));
	}

	public static double distance2(double x1, double y1, double x2, double y2){
		return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
	}

}


import java.util.Scanner;

public class C465 {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double r = input.nextInt();
		double x1 = input.nextInt();
		double y1 = input.nextInt();
		double x2 = input.nextInt();
		double y2 = input.nextInt();
		if (distance2(x1, y1, x2, y2) >= r * r){
			System.out.println(x1 + " " + y1 + " " + r);
		}else{
			double d = (r + Math.sqrt(distance2(x1, y1, x2, y2))) / 2;
			double x = (x1 - x2) / Math.abs(x1 - x2) * prop(x1, y1, x2, y2) * d + x2;
			double y = (y1 - y2) / Math.abs(y1 - y2) * prop(y1, x1, y2, x2) * d + y2;
			System.out.println(x + " " + y + " " + d);
		}
	}

	public static double prop(double x1, double y1, double x2, double y2){
		return Math.sqrt((x2 - x1) * (x2 - x1) / distance2(x1, y1, x2, y2));
	}

	public static double distance2(double x1, double y1, double x2, double y2){
		return (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
	}

}


import java.util.Scanner;

public class C465 {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		double r = input.nextInt();
		double x1 = input.nextInt();
		double y1 = input.nextInt();
		double x2 = input.nextInt();
		double y2 = input.nextInt();
		double xdist = x1 - x2;
		double ydist = y1 - y2;
		double dist2 = xdist * xdist + ydist * ydist;
		if (dist2 >= r * r){
			System.out.println(x1 + " " + y1 + " " + r);
		}else if (x1 != x2 || y1 != y2){
			double dist = Math.sqrt(dist2);
			double m = (dist + r) / 2;
			double x = x2 + xdist / dist * m;
			double y = y2 + ydist / dist * m;
			System.out.println(x + " " + y + " " + m);
		}else{
			double m = r / 2;
			double x = x2 + m;
			double y = y2;
			System.out.println(x + " " + y + " " + m);
		}
	}

}


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

public class MainA
{
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	static double ans=0;
	public static double dfs(int visited[],ArrayList<Integer> adj[],int v)
	{
		visited[v]=1;int count=0;double tem=0;
		for(int i=0;i<adj[v].size();i++)
		{
			if(visited[adj[v].get(i)]==0)
			{
				double d=dfs(visited,adj,adj[v].get(i));
				count++;
				tem+=d+1;
			}
		}

		double var=0;
		if(count!=0)var=tem/count;
		//pw.println(v+" "+ans+" "+var+" "+count);
		ans=ans+var;
		return var;

	}

	public static int find(Pair subsets[], int i)
	{
	    // find root and make root as parent of i (path compression)
	    if (subsets[i].x != i)
	        subsets[i].x = find(subsets, subsets[i].x);

	    return subsets[i].x;
	}

	// A function that does union of two sets of x and y
	// (uses union by rank)
	public static void Union(Pair subsets[], int x, int y)
	{
	    int xroot = find(subsets, x);
	    int yroot = find(subsets, y);

	    // Attach smaller rank tree under root of high rank tree
	    // (Union by Rank)
	    if (subsets[xroot].y < subsets[yroot].y)
	        subsets[xroot].x = yroot;
	    else if (subsets[xroot].y> subsets[yroot].y)
	        subsets[yroot].x = xroot;

	    // If ranks are same, then make one as root and increment
	    // its rank by one
	    else
	    {
	        subsets[yroot].x = xroot;
	        subsets[xroot].y++;
	    }
	}

	// The main function to check whether a given graph contains cycle or not
	public static int isCycle(int v1, int e1,String s1,String s2)
	{
	    int V = v1;
	    int E = e1;

	    // Allocate memory for creating V sets
	    Pair subsets[]=new Pair[V];

	    for (int v = 0; v < V; ++v)
	    {
	    	subsets[v]=new Pair(v,0);

	    }

	    // Iterate through all edges of graph, find sets of both
	    // vertices of every edge, if sets are same, then there is
	    // cycle in graph.
	    int count=0;
	    ArrayList<String> arr=new ArrayList();
	    for(int e = 0; e < E; ++e)
	    {
	        int x = find(subsets, s1.charAt(e)-'a');
	        int y = find(subsets, s2.charAt(e)-'a');

	        if (x != y)
	        {
	        	count++;
	        	arr.add(s1.charAt(e)+" "+s2.charAt(e));
	        	Union(subsets, x, y);
	        }
	    }
	    pw.println(count);
	    for(int i=0;i<count;i++)
	    {
	    	pw.println(arr.get(i));
	    }
	    return 0;
	}

	private static void soln()
	{
		double R=nextInt();
		double x1=nextInt();
		double y1=nextInt();
		double x2=nextInt();
		double y2=nextInt();
		double val=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)-Math.pow(R, 2);
		if(val>=0)
		{
			pw.println(x1+" "+y1+" "+R);
		}
		else if(x2==x1 && y2==y1)
		{
			pw.printf("%.10f %.10f %.10f",x1,y1+R/2,R/2);
		}
		else
		{
			double te=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2);
			double m=(Math.sqrt(te)+R);
			double n=R;
			double x3=(m*x1-n*x2)/(m-n);
			double y3=(m*y1-n*y2)/(m-n);
			double r=m/2;
			//pw.println(x3+" "+y3);
			double xa=(x2+x3)/2;
			double ya=(y2+y3)/2;
			//double dist=Math.sqrt(Math.pow(xa-x2, 2)+Math.pow(ya-y2, 2));

			pw.printf("%.10f %.10f %.10f",xa,ya,r);

		}
	}

	static class Pair implements Comparable<Pair>
    {

        int x,y,i;

        Pair (int x, int y)
        {
        		this.x = x;
                this.y = y;

        }

	public int compareTo(Pair o) {
                return -Integer.compare(this.y,o.y);
	}

        public boolean equals(Object o)
        {
            if (o instanceof Pair)
            {
                Pair p = (Pair)o;
                return p.x == x && p.y==y;
            }
            return false;
        }

        @Override
        public String toString()
        {
            return x + " "+ y;
        }

        public int hashCode()
        {
            return new Long(x).hashCode() * 31 + new Long(y).hashCode();
        }

    }

	public static int biSe(int x,int n)
	{
		int y=n*n-x;
		int l=1,r=n;
		while(l<=r)
		{
			int mid=(l+r)/2;
			//pw.println(mid+" "+f(mid,n)+" "+y);
			if(f(mid,n)==y)
			{
				return mid;
			}
			else if(f(mid,n)<y)
			{
				r=mid-1;
			}
			else l=mid+1;
		}
		return -1;
	}

	public static int f(int x,int n)
	{
		return (n/x)*(n/x);
	}
	public static class Segment
	{
		private int[] tree;
		private boolean[] lazy;
		private int size;
		private int n;
		private class node
		{
			private int a;
			private int b;
			private int c;
			public node(int x,int y,int z)
			{
				a=x;
				b=y;
				c=z;
			}
		}
		public Segment(int n)
		{
			//this.base=arr;
			int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
	        size = 2 * (int) Math.pow(2, x) - 1;
			tree=new int[size];
			lazy=new boolean[size];
			this.n=n;
			build(0,0,n-1);
		}
		public void build(int id,int l,int r)
		{
			if(l==r)
			{
				return;
			}
			int mid=(l+r)/2;
			build(2*id+1,l,mid);
			build(2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public int query(int l,int r)
		{
			return queryUtil(l,r,0,0,n-1);
		}
		private int queryUtil(int x,int y,int id,int l,int r)
		{
			if(l>y || x>r)
				return 0;
			if(x <= l && r<=y)
			{
				//if(!lazy[id])
					return tree[id];
				//else
				//	return tree[id][0];
			}
			int mid=l+(r-l)/2;
			shift(id);
			return queryUtil(x,y,2*id+1,l,mid)+queryUtil(x,y,2*id+2,mid+1,r);
		}
		public void update(int x,int y,int colour,int id,int l,int r)
		{
			//System.out.println(l+" "+r+" "+x);
			if(x>r || y<l)
				return;
			if(x <= l && r<=y)
			{

				return;
			}
			int mid=l+(r-l)/2;
			shift(id);
			update(x,y,colour,2*id+1,l,mid);
			update(x,y,colour,2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public void shift(int id)
		{

		}
	}

	public static void fft(double[] a, double[] b, boolean invert)
	{
		int count = a.length;
		for (int i = 1, j = 0; i < count; i++) {
			int bit = count >> 1;
			for (; j >= bit; bit >>= 1) j -= bit;
			j += bit;
			if (i < j) {
				double temp = a[i];
				a[i] = a[j];
				a[j] = temp;
				temp = b[i];
				b[i] = b[j];
				b[j] = temp;
			}
		}
		for (int len = 2; len <= count; len <<= 1) {
			int halfLen = len >> 1;
			double angle = 2 * Math.PI / len;
			if (invert) angle = -angle;
			double wLenA = Math.cos(angle), wLenB = Math.sin(angle);
			for (int i = 0; i < count; i += len) {
				double wA = 1, wB = 0;
				for (int j = 0; j < halfLen; j++) {
					double uA = a[i + j], uB = b[i + j];
					double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
					double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
					a[i + j] = uA + vA;
					b[i + j] = uB + vB;
					a[i + j + halfLen] = uA - vA;
					b[i + j + halfLen] = uB - vB;
					double nextWA = wA * wLenA - wB * wLenB;
					wB = wA * wLenB + wB * wLenA;
					wA = nextWA;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < count; i++) {
				a[i] /= count;
				b[i] /= count;
			}
		}
	}
	static void multiply(long[][] a, long[][] b, long m)
	{
		int n = a.length;
		long[][] mul = new long[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				mul[i][j] = 0;
				for (int k = 0; k < n; k++)
					mul[i][j] = (mul[i][j] + (a[i][k] * b[k][j]) % m) % m;
			}
		}
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				a[i][j] = mul[i][j];
	}

	private static long pow(long a, long b, long c)
	{
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private static long gcd(long n, long l)
	{
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}
	public static void main(String[] args) throws Exception
	{
//		new Thread(null, new Runnable()
//		{
//			@Override
//			public void run()
//			{
//				/*try {
//					InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				} */
//				InputReader(System.in);
//				pw = new PrintWriter(System.out);
//				/*try {
//					pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				}*/
//				soln();
//				pw.close();
//			}
//		}, "1", 1 << 26).start();

		/*try {
			InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		} */
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		/*try {
			pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		soln();
		pw.close();
	}

	public static void InputReader(InputStream stream1)
	{
		stream = stream1;
	}

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

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

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

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

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

	private static void pArray(int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c)
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private static char nextChar()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

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


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

public class MainA
{
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	static double ans=0;
	public static double dfs(int visited[],ArrayList<Integer> adj[],int v)
	{
		visited[v]=1;int count=0;double tem=0;
		for(int i=0;i<adj[v].size();i++)
		{
			if(visited[adj[v].get(i)]==0)
			{
				double d=dfs(visited,adj,adj[v].get(i));
				count++;
				tem+=d+1;
			}
		}

		double var=0;
		if(count!=0)var=tem/count;
		//pw.println(v+" "+ans+" "+var+" "+count);
		ans=ans+var;
		return var;

	}

	public static int find(Pair subsets[], int i)
	{
	    // find root and make root as parent of i (path compression)
	    if (subsets[i].x != i)
	        subsets[i].x = find(subsets, subsets[i].x);

	    return subsets[i].x;
	}

	// A function that does union of two sets of x and y
	// (uses union by rank)
	public static void Union(Pair subsets[], int x, int y)
	{
	    int xroot = find(subsets, x);
	    int yroot = find(subsets, y);

	    // Attach smaller rank tree under root of high rank tree
	    // (Union by Rank)
	    if (subsets[xroot].y < subsets[yroot].y)
	        subsets[xroot].x = yroot;
	    else if (subsets[xroot].y> subsets[yroot].y)
	        subsets[yroot].x = xroot;

	    // If ranks are same, then make one as root and increment
	    // its rank by one
	    else
	    {
	        subsets[yroot].x = xroot;
	        subsets[xroot].y++;
	    }
	}

	// The main function to check whether a given graph contains cycle or not
	public static int isCycle(int v1, int e1,String s1,String s2)
	{
	    int V = v1;
	    int E = e1;

	    // Allocate memory for creating V sets
	    Pair subsets[]=new Pair[V];

	    for (int v = 0; v < V; ++v)
	    {
	    	subsets[v]=new Pair(v,0);

	    }

	    // Iterate through all edges of graph, find sets of both
	    // vertices of every edge, if sets are same, then there is
	    // cycle in graph.
	    int count=0;
	    ArrayList<String> arr=new ArrayList();
	    for(int e = 0; e < E; ++e)
	    {
	        int x = find(subsets, s1.charAt(e)-'a');
	        int y = find(subsets, s2.charAt(e)-'a');

	        if (x != y)
	        {
	        	count++;
	        	arr.add(s1.charAt(e)+" "+s2.charAt(e));
	        	Union(subsets, x, y);
	        }
	    }
	    pw.println(count);
	    for(int i=0;i<count;i++)
	    {
	    	pw.println(arr.get(i));
	    }
	    return 0;
	}

	private static void soln()
	{
		double R=nextInt();
		double x1=nextInt();
		double y1=nextInt();
		double x2=nextInt();
		double y2=nextInt();
		double val=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)-Math.pow(R, 2);
		if(val>=0)
		{
			pw.println(x1+" "+y1+" "+R);
		}
		else
		{
			double te=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2);
			double m=(Math.sqrt(te)+R);
			double n=R;
			double x3=(m*x1-n*x2)/(m-n);
			double y3=(m*y1-n*y2)/(m-n);
			double r=m/2;
			//pw.println(x3+" "+y3);
			double xa=(x2+x3)/2;
			double ya=(y2+y3)/2;
			pw.printf("%.7f %.7f %.7f",xa,ya,r);

		}
	}

	static class Pair implements Comparable<Pair>
    {

        int x,y,i;

        Pair (int x, int y)
        {
        		this.x = x;
                this.y = y;

        }

	public int compareTo(Pair o) {
                return -Integer.compare(this.y,o.y);
	}

        public boolean equals(Object o)
        {
            if (o instanceof Pair)
            {
                Pair p = (Pair)o;
                return p.x == x && p.y==y;
            }
            return false;
        }

        @Override
        public String toString()
        {
            return x + " "+ y;
        }

        public int hashCode()
        {
            return new Long(x).hashCode() * 31 + new Long(y).hashCode();
        }

    }

	public static int biSe(int x,int n)
	{
		int y=n*n-x;
		int l=1,r=n;
		while(l<=r)
		{
			int mid=(l+r)/2;
			//pw.println(mid+" "+f(mid,n)+" "+y);
			if(f(mid,n)==y)
			{
				return mid;
			}
			else if(f(mid,n)<y)
			{
				r=mid-1;
			}
			else l=mid+1;
		}
		return -1;
	}

	public static int f(int x,int n)
	{
		return (n/x)*(n/x);
	}
	public static class Segment
	{
		private int[] tree;
		private boolean[] lazy;
		private int size;
		private int n;
		private class node
		{
			private int a;
			private int b;
			private int c;
			public node(int x,int y,int z)
			{
				a=x;
				b=y;
				c=z;
			}
		}
		public Segment(int n)
		{
			//this.base=arr;
			int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
	        size = 2 * (int) Math.pow(2, x) - 1;
			tree=new int[size];
			lazy=new boolean[size];
			this.n=n;
			build(0,0,n-1);
		}
		public void build(int id,int l,int r)
		{
			if(l==r)
			{
				return;
			}
			int mid=(l+r)/2;
			build(2*id+1,l,mid);
			build(2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public int query(int l,int r)
		{
			return queryUtil(l,r,0,0,n-1);
		}
		private int queryUtil(int x,int y,int id,int l,int r)
		{
			if(l>y || x>r)
				return 0;
			if(x <= l && r<=y)
			{
				//if(!lazy[id])
					return tree[id];
				//else
				//	return tree[id][0];
			}
			int mid=l+(r-l)/2;
			shift(id);
			return queryUtil(x,y,2*id+1,l,mid)+queryUtil(x,y,2*id+2,mid+1,r);
		}
		public void update(int x,int y,int colour,int id,int l,int r)
		{
			//System.out.println(l+" "+r+" "+x);
			if(x>r || y<l)
				return;
			if(x <= l && r<=y)
			{

				return;
			}
			int mid=l+(r-l)/2;
			shift(id);
			update(x,y,colour,2*id+1,l,mid);
			update(x,y,colour,2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public void shift(int id)
		{

		}
	}

	public static void fft(double[] a, double[] b, boolean invert)
	{
		int count = a.length;
		for (int i = 1, j = 0; i < count; i++) {
			int bit = count >> 1;
			for (; j >= bit; bit >>= 1) j -= bit;
			j += bit;
			if (i < j) {
				double temp = a[i];
				a[i] = a[j];
				a[j] = temp;
				temp = b[i];
				b[i] = b[j];
				b[j] = temp;
			}
		}
		for (int len = 2; len <= count; len <<= 1) {
			int halfLen = len >> 1;
			double angle = 2 * Math.PI / len;
			if (invert) angle = -angle;
			double wLenA = Math.cos(angle), wLenB = Math.sin(angle);
			for (int i = 0; i < count; i += len) {
				double wA = 1, wB = 0;
				for (int j = 0; j < halfLen; j++) {
					double uA = a[i + j], uB = b[i + j];
					double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
					double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
					a[i + j] = uA + vA;
					b[i + j] = uB + vB;
					a[i + j + halfLen] = uA - vA;
					b[i + j + halfLen] = uB - vB;
					double nextWA = wA * wLenA - wB * wLenB;
					wB = wA * wLenB + wB * wLenA;
					wA = nextWA;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < count; i++) {
				a[i] /= count;
				b[i] /= count;
			}
		}
	}
	static void multiply(long[][] a, long[][] b, long m)
	{
		int n = a.length;
		long[][] mul = new long[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				mul[i][j] = 0;
				for (int k = 0; k < n; k++)
					mul[i][j] = (mul[i][j] + (a[i][k] * b[k][j]) % m) % m;
			}
		}
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				a[i][j] = mul[i][j];
	}

	private static long pow(long a, long b, long c)
	{
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private static long gcd(long n, long l)
	{
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}
	public static void main(String[] args) throws Exception
	{
//		new Thread(null, new Runnable()
//		{
//			@Override
//			public void run()
//			{
//				/*try {
//					InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				} */
//				InputReader(System.in);
//				pw = new PrintWriter(System.out);
//				/*try {
//					pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				}*/
//				soln();
//				pw.close();
//			}
//		}, "1", 1 << 26).start();

		/*try {
			InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		} */
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		/*try {
			pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		soln();
		pw.close();
	}

	public static void InputReader(InputStream stream1)
	{
		stream = stream1;
	}

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

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

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

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

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

	private static void pArray(int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c)
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private static char nextChar()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

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


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

public class MainA
{
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	static double ans=0;
	public static double dfs(int visited[],ArrayList<Integer> adj[],int v)
	{
		visited[v]=1;int count=0;double tem=0;
		for(int i=0;i<adj[v].size();i++)
		{
			if(visited[adj[v].get(i)]==0)
			{
				double d=dfs(visited,adj,adj[v].get(i));
				count++;
				tem+=d+1;
			}
		}

		double var=0;
		if(count!=0)var=tem/count;
		//pw.println(v+" "+ans+" "+var+" "+count);
		ans=ans+var;
		return var;

	}

	public static int find(Pair subsets[], int i)
	{
	    // find root and make root as parent of i (path compression)
	    if (subsets[i].x != i)
	        subsets[i].x = find(subsets, subsets[i].x);

	    return subsets[i].x;
	}

	// A function that does union of two sets of x and y
	// (uses union by rank)
	public static void Union(Pair subsets[], int x, int y)
	{
	    int xroot = find(subsets, x);
	    int yroot = find(subsets, y);

	    // Attach smaller rank tree under root of high rank tree
	    // (Union by Rank)
	    if (subsets[xroot].y < subsets[yroot].y)
	        subsets[xroot].x = yroot;
	    else if (subsets[xroot].y> subsets[yroot].y)
	        subsets[yroot].x = xroot;

	    // If ranks are same, then make one as root and increment
	    // its rank by one
	    else
	    {
	        subsets[yroot].x = xroot;
	        subsets[xroot].y++;
	    }
	}

	// The main function to check whether a given graph contains cycle or not
	public static int isCycle(int v1, int e1,String s1,String s2)
	{
	    int V = v1;
	    int E = e1;

	    // Allocate memory for creating V sets
	    Pair subsets[]=new Pair[V];

	    for (int v = 0; v < V; ++v)
	    {
	    	subsets[v]=new Pair(v,0);

	    }

	    // Iterate through all edges of graph, find sets of both
	    // vertices of every edge, if sets are same, then there is
	    // cycle in graph.
	    int count=0;
	    ArrayList<String> arr=new ArrayList();
	    for(int e = 0; e < E; ++e)
	    {
	        int x = find(subsets, s1.charAt(e)-'a');
	        int y = find(subsets, s2.charAt(e)-'a');

	        if (x != y)
	        {
	        	count++;
	        	arr.add(s1.charAt(e)+" "+s2.charAt(e));
	        	Union(subsets, x, y);
	        }
	    }
	    pw.println(count);
	    for(int i=0;i<count;i++)
	    {
	    	pw.println(arr.get(i));
	    }
	    return 0;
	}

	private static void soln()
	{
		double R=nextInt();
		double x1=nextInt();
		double y1=nextInt();
		double x2=nextInt();
		double y2=nextInt();
		double val=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)-Math.pow(R, 2);
		if(val>=0)
		{
			pw.println(x1+" "+y1+" "+R);
		}
		else
		{
			double te=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2);
			double m=(Math.sqrt(te)+R);
			double n=R;
			double x3=(m*x1-n*x2)/(m-n);
			double y3=(m*y1-n*y2)/(m-n);
			double r=m/2;
			//pw.println(x3+" "+y3);
			double xa=(x2+x3)/2;
			double ya=(y2+y3)/2;
			pw.printf("%.10f %.10f %.10f",xa,ya,r);

		}
	}

	static class Pair implements Comparable<Pair>
    {

        int x,y,i;

        Pair (int x, int y)
        {
        		this.x = x;
                this.y = y;

        }

	public int compareTo(Pair o) {
                return -Integer.compare(this.y,o.y);
	}

        public boolean equals(Object o)
        {
            if (o instanceof Pair)
            {
                Pair p = (Pair)o;
                return p.x == x && p.y==y;
            }
            return false;
        }

        @Override
        public String toString()
        {
            return x + " "+ y;
        }

        public int hashCode()
        {
            return new Long(x).hashCode() * 31 + new Long(y).hashCode();
        }

    }

	public static int biSe(int x,int n)
	{
		int y=n*n-x;
		int l=1,r=n;
		while(l<=r)
		{
			int mid=(l+r)/2;
			//pw.println(mid+" "+f(mid,n)+" "+y);
			if(f(mid,n)==y)
			{
				return mid;
			}
			else if(f(mid,n)<y)
			{
				r=mid-1;
			}
			else l=mid+1;
		}
		return -1;
	}

	public static int f(int x,int n)
	{
		return (n/x)*(n/x);
	}
	public static class Segment
	{
		private int[] tree;
		private boolean[] lazy;
		private int size;
		private int n;
		private class node
		{
			private int a;
			private int b;
			private int c;
			public node(int x,int y,int z)
			{
				a=x;
				b=y;
				c=z;
			}
		}
		public Segment(int n)
		{
			//this.base=arr;
			int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
	        size = 2 * (int) Math.pow(2, x) - 1;
			tree=new int[size];
			lazy=new boolean[size];
			this.n=n;
			build(0,0,n-1);
		}
		public void build(int id,int l,int r)
		{
			if(l==r)
			{
				return;
			}
			int mid=(l+r)/2;
			build(2*id+1,l,mid);
			build(2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public int query(int l,int r)
		{
			return queryUtil(l,r,0,0,n-1);
		}
		private int queryUtil(int x,int y,int id,int l,int r)
		{
			if(l>y || x>r)
				return 0;
			if(x <= l && r<=y)
			{
				//if(!lazy[id])
					return tree[id];
				//else
				//	return tree[id][0];
			}
			int mid=l+(r-l)/2;
			shift(id);
			return queryUtil(x,y,2*id+1,l,mid)+queryUtil(x,y,2*id+2,mid+1,r);
		}
		public void update(int x,int y,int colour,int id,int l,int r)
		{
			//System.out.println(l+" "+r+" "+x);
			if(x>r || y<l)
				return;
			if(x <= l && r<=y)
			{

				return;
			}
			int mid=l+(r-l)/2;
			shift(id);
			update(x,y,colour,2*id+1,l,mid);
			update(x,y,colour,2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public void shift(int id)
		{

		}
	}

	public static void fft(double[] a, double[] b, boolean invert)
	{
		int count = a.length;
		for (int i = 1, j = 0; i < count; i++) {
			int bit = count >> 1;
			for (; j >= bit; bit >>= 1) j -= bit;
			j += bit;
			if (i < j) {
				double temp = a[i];
				a[i] = a[j];
				a[j] = temp;
				temp = b[i];
				b[i] = b[j];
				b[j] = temp;
			}
		}
		for (int len = 2; len <= count; len <<= 1) {
			int halfLen = len >> 1;
			double angle = 2 * Math.PI / len;
			if (invert) angle = -angle;
			double wLenA = Math.cos(angle), wLenB = Math.sin(angle);
			for (int i = 0; i < count; i += len) {
				double wA = 1, wB = 0;
				for (int j = 0; j < halfLen; j++) {
					double uA = a[i + j], uB = b[i + j];
					double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
					double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
					a[i + j] = uA + vA;
					b[i + j] = uB + vB;
					a[i + j + halfLen] = uA - vA;
					b[i + j + halfLen] = uB - vB;
					double nextWA = wA * wLenA - wB * wLenB;
					wB = wA * wLenB + wB * wLenA;
					wA = nextWA;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < count; i++) {
				a[i] /= count;
				b[i] /= count;
			}
		}
	}
	static void multiply(long[][] a, long[][] b, long m)
	{
		int n = a.length;
		long[][] mul = new long[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				mul[i][j] = 0;
				for (int k = 0; k < n; k++)
					mul[i][j] = (mul[i][j] + (a[i][k] * b[k][j]) % m) % m;
			}
		}
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				a[i][j] = mul[i][j];
	}

	private static long pow(long a, long b, long c)
	{
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private static long gcd(long n, long l)
	{
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}
	public static void main(String[] args) throws Exception
	{
//		new Thread(null, new Runnable()
//		{
//			@Override
//			public void run()
//			{
//				/*try {
//					InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				} */
//				InputReader(System.in);
//				pw = new PrintWriter(System.out);
//				/*try {
//					pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				}*/
//				soln();
//				pw.close();
//			}
//		}, "1", 1 << 26).start();

		/*try {
			InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		} */
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		/*try {
			pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		soln();
		pw.close();
	}

	public static void InputReader(InputStream stream1)
	{
		stream = stream1;
	}

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

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

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

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

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

	private static void pArray(int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c)
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private static char nextChar()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

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


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

public class MainA
{
	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
	private static long mod = 1000000000 + 7;
	static double ans=0;
	public static double dfs(int visited[],ArrayList<Integer> adj[],int v)
	{
		visited[v]=1;int count=0;double tem=0;
		for(int i=0;i<adj[v].size();i++)
		{
			if(visited[adj[v].get(i)]==0)
			{
				double d=dfs(visited,adj,adj[v].get(i));
				count++;
				tem+=d+1;
			}
		}

		double var=0;
		if(count!=0)var=tem/count;
		//pw.println(v+" "+ans+" "+var+" "+count);
		ans=ans+var;
		return var;

	}

	public static int find(Pair subsets[], int i)
	{
	    // find root and make root as parent of i (path compression)
	    if (subsets[i].x != i)
	        subsets[i].x = find(subsets, subsets[i].x);

	    return subsets[i].x;
	}

	// A function that does union of two sets of x and y
	// (uses union by rank)
	public static void Union(Pair subsets[], int x, int y)
	{
	    int xroot = find(subsets, x);
	    int yroot = find(subsets, y);

	    // Attach smaller rank tree under root of high rank tree
	    // (Union by Rank)
	    if (subsets[xroot].y < subsets[yroot].y)
	        subsets[xroot].x = yroot;
	    else if (subsets[xroot].y> subsets[yroot].y)
	        subsets[yroot].x = xroot;

	    // If ranks are same, then make one as root and increment
	    // its rank by one
	    else
	    {
	        subsets[yroot].x = xroot;
	        subsets[xroot].y++;
	    }
	}

	// The main function to check whether a given graph contains cycle or not
	public static int isCycle(int v1, int e1,String s1,String s2)
	{
	    int V = v1;
	    int E = e1;

	    // Allocate memory for creating V sets
	    Pair subsets[]=new Pair[V];

	    for (int v = 0; v < V; ++v)
	    {
	    	subsets[v]=new Pair(v,0);

	    }

	    // Iterate through all edges of graph, find sets of both
	    // vertices of every edge, if sets are same, then there is
	    // cycle in graph.
	    int count=0;
	    ArrayList<String> arr=new ArrayList();
	    for(int e = 0; e < E; ++e)
	    {
	        int x = find(subsets, s1.charAt(e)-'a');
	        int y = find(subsets, s2.charAt(e)-'a');

	        if (x != y)
	        {
	        	count++;
	        	arr.add(s1.charAt(e)+" "+s2.charAt(e));
	        	Union(subsets, x, y);
	        }
	    }
	    pw.println(count);
	    for(int i=0;i<count;i++)
	    {
	    	pw.println(arr.get(i));
	    }
	    return 0;
	}

	private static void soln()
	{
		double R=nextInt();
		double x1=nextInt();
		double y1=nextInt();
		double x2=nextInt();
		double y2=nextInt();
		double val=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2)-Math.pow(R, 2);
		if(val>=0)
		{
			pw.println(x1+" "+y1+" "+R);
		}
		else
		{
			double te=Math.pow(x2-x1, 2)+Math.pow(y2-y1, 2);
			double m=(Math.sqrt(te)+R);
			double n=R;
			double x3=(m*x1-n*x2)/(m-n);
			double y3=(m*y1-n*y2)/(m-n);
			double r=m/2;
			//pw.println(x3+" "+y3);
			double xa=(x2+x3)/2;
			double ya=(y2+y3)/2;
			double dist=Math.sqrt(Math.pow(xa-x2, 2)+Math.pow(ya-y2, 2));

			pw.printf("%.10f %.10f %.10f\n",xa,ya,dist);

		}
	}

	static class Pair implements Comparable<Pair>
    {

        int x,y,i;

        Pair (int x, int y)
        {
        		this.x = x;
                this.y = y;

        }

	public int compareTo(Pair o) {
                return -Integer.compare(this.y,o.y);
	}

        public boolean equals(Object o)
        {
            if (o instanceof Pair)
            {
                Pair p = (Pair)o;
                return p.x == x && p.y==y;
            }
            return false;
        }

        @Override
        public String toString()
        {
            return x + " "+ y;
        }

        public int hashCode()
        {
            return new Long(x).hashCode() * 31 + new Long(y).hashCode();
        }

    }

	public static int biSe(int x,int n)
	{
		int y=n*n-x;
		int l=1,r=n;
		while(l<=r)
		{
			int mid=(l+r)/2;
			//pw.println(mid+" "+f(mid,n)+" "+y);
			if(f(mid,n)==y)
			{
				return mid;
			}
			else if(f(mid,n)<y)
			{
				r=mid-1;
			}
			else l=mid+1;
		}
		return -1;
	}

	public static int f(int x,int n)
	{
		return (n/x)*(n/x);
	}
	public static class Segment
	{
		private int[] tree;
		private boolean[] lazy;
		private int size;
		private int n;
		private class node
		{
			private int a;
			private int b;
			private int c;
			public node(int x,int y,int z)
			{
				a=x;
				b=y;
				c=z;
			}
		}
		public Segment(int n)
		{
			//this.base=arr;
			int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
	        size = 2 * (int) Math.pow(2, x) - 1;
			tree=new int[size];
			lazy=new boolean[size];
			this.n=n;
			build(0,0,n-1);
		}
		public void build(int id,int l,int r)
		{
			if(l==r)
			{
				return;
			}
			int mid=(l+r)/2;
			build(2*id+1,l,mid);
			build(2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public int query(int l,int r)
		{
			return queryUtil(l,r,0,0,n-1);
		}
		private int queryUtil(int x,int y,int id,int l,int r)
		{
			if(l>y || x>r)
				return 0;
			if(x <= l && r<=y)
			{
				//if(!lazy[id])
					return tree[id];
				//else
				//	return tree[id][0];
			}
			int mid=l+(r-l)/2;
			shift(id);
			return queryUtil(x,y,2*id+1,l,mid)+queryUtil(x,y,2*id+2,mid+1,r);
		}
		public void update(int x,int y,int colour,int id,int l,int r)
		{
			//System.out.println(l+" "+r+" "+x);
			if(x>r || y<l)
				return;
			if(x <= l && r<=y)
			{

				return;
			}
			int mid=l+(r-l)/2;
			shift(id);
			update(x,y,colour,2*id+1,l,mid);
			update(x,y,colour,2*id+2,mid+1,r);
			tree[id]=tree[2*id+1]+tree[2*id+2];
		}
		public void shift(int id)
		{

		}
	}

	public static void fft(double[] a, double[] b, boolean invert)
	{
		int count = a.length;
		for (int i = 1, j = 0; i < count; i++) {
			int bit = count >> 1;
			for (; j >= bit; bit >>= 1) j -= bit;
			j += bit;
			if (i < j) {
				double temp = a[i];
				a[i] = a[j];
				a[j] = temp;
				temp = b[i];
				b[i] = b[j];
				b[j] = temp;
			}
		}
		for (int len = 2; len <= count; len <<= 1) {
			int halfLen = len >> 1;
			double angle = 2 * Math.PI / len;
			if (invert) angle = -angle;
			double wLenA = Math.cos(angle), wLenB = Math.sin(angle);
			for (int i = 0; i < count; i += len) {
				double wA = 1, wB = 0;
				for (int j = 0; j < halfLen; j++) {
					double uA = a[i + j], uB = b[i + j];
					double vA = a[i + j + halfLen] * wA - b[i + j + halfLen] * wB;
					double vB = a[i + j + halfLen] * wB + b[i + j + halfLen] * wA;
					a[i + j] = uA + vA;
					b[i + j] = uB + vB;
					a[i + j + halfLen] = uA - vA;
					b[i + j + halfLen] = uB - vB;
					double nextWA = wA * wLenA - wB * wLenB;
					wB = wA * wLenB + wB * wLenA;
					wA = nextWA;
				}
			}
		}
		if (invert) {
			for (int i = 0; i < count; i++) {
				a[i] /= count;
				b[i] /= count;
			}
		}
	}
	static void multiply(long[][] a, long[][] b, long m)
	{
		int n = a.length;
		long[][] mul = new long[n][n];
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				mul[i][j] = 0;
				for (int k = 0; k < n; k++)
					mul[i][j] = (mul[i][j] + (a[i][k] * b[k][j]) % m) % m;
			}
		}
		for (int i = 0; i < n; i++)
			for (int j = 0; j < n; j++)
				a[i][j] = mul[i][j];
	}

	private static long pow(long a, long b, long c)
	{
		if (b == 0)
			return 1;
		long p = pow(a, b / 2, c);
		p = (p * p) % c;
		return (b % 2 == 0) ? p : (a * p) % c;
	}

	private static long gcd(long n, long l)
	{
		if (l == 0)
			return n;
		return gcd(l, n % l);
	}
	public static void main(String[] args) throws Exception
	{
//		new Thread(null, new Runnable()
//		{
//			@Override
//			public void run()
//			{
//				/*try {
//					InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				} */
//				InputReader(System.in);
//				pw = new PrintWriter(System.out);
//				/*try {
//					pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
//				} catch (FileNotFoundException e) { // TODO Auto-generated catch block
//					e.printStackTrace();
//				}*/
//				soln();
//				pw.close();
//			}
//		}, "1", 1 << 26).start();

		/*try {
			InputReader(new FileInputStream("C:\\Users\\hardik\\Desktop\\B-large-practice.in"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		} */
		InputReader(System.in);
		pw = new PrintWriter(System.out);
		/*try {
			pw=new PrintWriter(new FileOutputStream("C:\\Users\\hardik\\Desktop\\out.txt"));
		} catch (FileNotFoundException e) { // TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		soln();
		pw.close();
	}

	public static void InputReader(InputStream stream1)
	{
		stream = stream1;
	}

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

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

	private static 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++];
	}

	private static 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;
	}

	private static 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;
	}

	private static String nextToken()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	private static String nextLine()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do
		{
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}

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

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

	private static void pArray(int[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static void pArray(long[] arr)
	{
		for (int i = 0; i < arr.length; i++)
		{
			System.out.print(arr[i] + " ");
		}
		System.out.println();
		return;
	}

	private static boolean isSpaceChar(int c)
	{
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	private static char nextChar()
	{
		int c = read();
		while (isSpaceChar(c))
			c = read();
		char c1 = (char) c;
		while (!isSpaceChar(c))
			c = read();
		return c1;
	}

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


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {

	static Random r = new Random();

	public static void main(String[] args) throws IOException {
		MyScanner sc = new MyScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int R = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		if((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)>=R*R) {
			pw.printf("%06f %06f %06f\n", (double)x1, (double)y1, (double)R);
			pw.close();
			return;
		}
		double PQ = dist(x1, y1, x2, y2);
		double r = (PQ+R)/2;
		double SQ = R - r;
		// SP = r;
		double x3 = (-SQ*x2+r*x1)/(-SQ+r);
		double y3 = (-SQ*y2+r*y1)/(-SQ+r);
		pw.printf("%06f %06f %06f\n", x3, y3, r);
		pw.close();
	}

	static double dist(double x1, double y1, double x2, double y2) {
		return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
	}

	static class MyScanner
	{
		BufferedReader br;
		StringTokenizer st;
		public MyScanner(InputStream s)
		{
			br=new BufferedReader(new InputStreamReader(s));
		}
		public String nextLine() throws IOException
		{
			return br.readLine();
		}
		public String next() throws IOException
		{
			while(st==null || !st.hasMoreTokens())
				st=new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());

		}
		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}
		public boolean ready() throws IOException
		{
			return br.ready();
		}
		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {
		MyScanner sc = new MyScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int R = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		if((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)>=R*R) {
			pw.println(x1 + " " + y1 + " " + R);
			pw.close();
			return;
		}
		if(x1==x2) {
			int x0 = x1;
			double y0;
			if(Math.abs(R)>=Math.abs(y1-y2)) {
				y0 = y1+R;
			} else {
				y0 = y1-R;
			}
			double xop = (x0+x2)/2.0; double yop = (y0+y2)/2.0;
			pw.println(xop + " " + yop + " " + Math.sqrt((xop-x0)*(xop-x0)+(yop-y0)*(yop-y0)));
			pw.close();
			return;
		}
		double a = (double)(y2-y1)/(double)(x2-x1);
		double b = y2-a*x2;
		double A = a*a+1;
		double B = x1-a*b+a*y1;
		double C = x1*x1+b*b-2*b*y1+y1*y1-R*R;
		double tmp1x0 = (B+Math.sqrt(B*B-A*C))/A;
		double tmp1y0 = a*tmp1x0+b;
		double tmp2x0 = (B-Math.sqrt(B*B-A*C))/A;
		double tmp2y0 = a*tmp2x0+b;
		double x0; double y0;
		if((tmp1x0-x1)*(tmp1x0-x1)+(tmp1y0-y1)*(tmp1y0-y1)<(tmp1x0-x2)*(tmp1x0-x2)+(tmp1y0-y2)*(tmp1y0-y2)) {
			x0 = tmp1x0; y0 = tmp1y0;
		} else {
			x0 = tmp2x0; y0 = tmp2y0;
		}
		double xop = (x0+x2)/2.0; double yop = (y0+y2)/2.0;
		pw.println(xop + " " + yop + " " + Math.sqrt((xop-x0)*(xop-x0)+(yop-y0)*(yop-y0)));
		pw.close();
	}

	static class MyScanner
	{
		BufferedReader br;
		StringTokenizer st;
		public MyScanner(InputStream s)
		{
			br=new BufferedReader(new InputStreamReader(s));
		}
		public String nextLine() throws IOException
		{
			return br.readLine();
		}
		public String next() throws IOException
		{
			while(st==null || !st.hasMoreTokens())
				st=new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());

		}
		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}
		public boolean ready() throws IOException
		{
			return br.ready();
		}
		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class Main {

	static Random r = new Random();

	public static void main(String[] args) throws IOException {
		MyScanner sc = new MyScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int R = sc.nextInt();
		int x1 = sc.nextInt();
		int y1 = sc.nextInt();
		int x2 = sc.nextInt();
		int y2 = sc.nextInt();
		if((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)>=R*R) {
			pw.println(x1 + " " + y1 + " " + R);
			pw.close();
			return;
		}
		double PQ = dist(x1, y1, x2, y2);
		double r = (PQ+R)/2;
		double SQ = R - r;
		// SP = r;
		double x3 = (-SQ*x2+r*x1)/(-SQ+r);
		double y3 = (-SQ*y2+r*y1)/(-SQ+r);
		pw.println(x3 + " " + y3 + " " + r);
		pw.close();
	}

	static double dist(double x1, double y1, double x2, double y2) {
		return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
	}

	static class MyScanner
	{
		BufferedReader br;
		StringTokenizer st;
		public MyScanner(InputStream s)
		{
			br=new BufferedReader(new InputStreamReader(s));
		}
		public String nextLine() throws IOException
		{
			return br.readLine();
		}
		public String next() throws IOException
		{
			while(st==null || !st.hasMoreTokens())
				st=new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());

		}
		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}
		public boolean ready() throws IOException
		{
			return br.ready();
		}
		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}
	}
}


By tspn, contest: Codeforces Round #465 (Div. 2), problem: (C) Fifa and Fafa, Compilation error, #

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

public class C {

	public static void main(String[] args) throws IOException {
		MyScanner sc = new MyScanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		long R = sc.nextInt();
		long x1 = sc.nextInt();
		long y1 = sc.nextInt();
		long x2 = sc.nextInt();
		long y2 = sc.nextInt();
		if((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)>=R*R) {
			pw.println(x1 + " " + y1 + " " + R);
			pw.close();
			return;
		}
		if(x1==x2) {
			long x0 = x1;
			double y0;
			if(Math.abs(R)>=Math.abs(y1-y2)) {
				y0 = y1+R;
			} else {
				y0 = y1-R;
			}
			double xop = (x0+x2)/2.0; double yop = (y0+y2)/2.0;
			pw.println(xop + " " + yop + " " + Math.sqrt((xop-x0)*(xop-x0)+(yop-y0)*(yop-y0)));
			pw.close();
			return;
		}
		double a = (double)(y2-y1)/(double)(x2-x1);
		double b = y2-a*x2;
		double A = a*a+1;
		double B = x1-a*b+a*y1;
		double C = x1*x1+b*b-2*b*y1+y1*y1-R*R;
		double tmp1x0 = (B+Math.sqrt(B*B-A*C))/A;
		double tmp1y0 = a*tmp1x0+b;
		double tmp2x0 = (B-Math.sqrt(B*B-A*C))/A;
		double tmp2y0 = a*tmp2x0+b;
		double x0; double y0;
		if((tmp1x0-x1)*(tmp1x0-x1)+(tmp1y0-y1)*(tmp1y0-y1)<(tmp1x0-x2)*(tmp1x0-x2)+(tmp1y0-y2)*(tmp1y0-y2)) {
			x0 = tmp1x0; y0 = tmp1y0;
		} else {
			x0 = tmp2x0; y0 = tmp2y0;
		}
		double xop = (x0+x2)/2.0; double yop = (y0+y2)/2.0;
		pw.println(xop + " " + yop + " " + Math.sqrt((xop-x0)*(xop-x0)+(yop-y0)*(yop-y0)));
		pw.close();
	}

	static class MyScanner
	{
		BufferedReader br;
		StringTokenizer st;
		public MyScanner(InputStream s)
		{
			br=new BufferedReader(new InputStreamReader(s));
		}
		public String nextLine() throws IOException
		{
			return br.readLine();
		}
		public String next() throws IOException
		{
			while(st==null || !st.hasMoreTokens())
				st=new StringTokenizer(br.readLine());
			return st.nextToken();
		}
		public int nextInt() throws IOException
		{
			return Integer.parseInt(next());

		}
		public double nextDouble() throws IOException
		{
			return Double.parseDouble(next());
		}
		public boolean ready() throws IOException
		{
			return br.ready();
		}
		public long nextLong() throws IOException
		{
			return Long.parseLong(next());
		}
	}
}


#include<bits/stdc++.h>

#define ll long long
#define mk make_pair
#define pb push_back

using namespace std;

const int N = 30;

int main()
{
	ios_base::sync_with_stdio(false);

	int h = 0;
	string s;
	vector<char> v;
	cin >> s;
	for(unsigned int i=0;i<s.size();)
	{
		if(s[i+1] == '/')
		{
			v.pb((char)(s[i+2] - N));
// 			cout << s[i+2] << endl;
			i+=4;
		}
		else
		{
// 			cout << s[i+1] << endl;
			v.pb(s[i+1]);
			i+=3;
		}
// 		cout << v.back() << endl;
	}

	for(unsigned int i=0;i<v.size();i++)
	{
// 		cout << (int)v[i] << " " << (int)'z' << endl;
		if(v[i] >= 'a')
		{
			for(int j=0;j<h;j++)
				cout << "  ";
			cout << '<' << v[i] << '>' << endl;
			++h;
		}
		else
		{
			--h;
			for(int j=0;j<h;j++)
				cout << "  ";
			cout << "</" << (char)(v[i] + N) << ">" << endl;
		}
	}

	return 0;
}


///***###                               بسم الله الرحمن الرحيم                            ###***///

/*
                    Author          : Borhan Uddin Rafi
                    University      : Begum Rokeya University,Rangpur.
                    Date            : 12 August,2020;
*/

///************************Start Of Template*************************///

#include<iostream>
#include<bits/stdc++.h>
#include<algorithm>
#include<math.h>
#define Read_Fast    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define PI acos(-1)
#define all(a) a.begin(),a.end()
#define f first
#define s second
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define mp make_pair
#define f0(i,n) for(i=0;i<n;i++)
#define f1(i,n) for(i=1;i<n;i++)
#define f1n(i,n) for(i=1;i<=n;i++)
#define szf sizeof()
#define sz size()
#define ln length()
#define mem(x,r) memset(x,r,sizeof(x))
#define inf 1000000000000
using namespace std;
using ll=long long;
const int N=1e5+4;

map<string,string>maap;

//////graph////////
vector<int>circle;
bool vis[N];
int parent[N];
int chk[N];
int color[N];
int tim[2][N];
int dis[N];
int position[N];
vector<int>adj[N];
vector<int>adj1[N];
//vector<pair<ll,ll>>adj[N];
vector<int>graph[N];
bool has_cycle;
int maxdis,maxnode,Totnode,depth=1;
bool ok;
queue<int>q;
stack<int>stk;
vector<int>solution;
int indegree[N];
int go[N];
int to[N];
map<int,int>mp1;

//////graph////////

/*** this solution will not work if freopen  terminal are open................
    If you close that freopen then its work here.
    But before submission you need to open freopen line when submit .text file***/

////calculate the path //////

//////////main function////////

int main()
{
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    Read_Fast;
    int t;
    // cin>>t;
    int cas=0;
    // while(t--)
    // {
    ll n,m,i,j,cnt1=0,cnt2=0,cnt=0,even=0,odd=0,len,k,r,l,z=0,x=0,y=0,flag=0,sum=0;
    ll a=0,b=0,c=0,d=0,ans=0,rem,quot,zero=0,fst=0,null=0,snd=0,lst=0,rone=0,one=0,pos=0,neg=0,mn=INT_MAX,mx=INT_MIN;

    char ch;

    ////Time/////
    int h1,h2,m1,m2,h;

    ////motion ////
    int velo1,velo2,ac1,ac2,time;

    /////Graph///
    int node,edge,u,v,cost;
    string str,str1="",str2="",str3="",strstore1="",strstore2="";

    //////Input Node ////
    int best,worst;
    cin>>str;
    n=str.size();
    cnt=-1;
    for(int i=0; i<n;)
    {
        if(str[i+1]!='/')
        {
            cnt++;
            for(int j=0; j<2*cnt; j++)
            {
                cout<<" ";
            }
            x++;
            cout<<str[i]<<str[i+1]<<str[i+2]<<endl;
            i+=3;
        }
        else
        {
            for(int j=0; j<2*cnt; j++)
            {
                cout<<" ";
            }
            cnt--;
            cout<<str[i]<<str[i+1]<<str[i+2]<<str[i+3]<<endl;
            i+=4;

        }

    }

    // }
    return 0;
///***###            ٱلْحَمْدُ لِلَّٰهِ          ###***///
}


///***###                               بسم الله الرحمن الرحيم                            ###***///

/*
                    Author          : Borhan Uddin Rafi
                    University      : Begum Rokeya University,Rangpur.
                    Date            : 12 August,2020;
*/

///************************Start Of Template*************************///

#include<iostream>
#include<bits/stdc++.h>
#include<algorithm>
#include<math.h>
#define Read_Fast    ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define PI acos(-1)
#define all(a) a.begin(),a.end()
#define f first
#define s second
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define mp make_pair
#define f0(i,n) for(i=0;i<n;i++)
#define f1(i,n) for(i=1;i<n;i++)
#define f1n(i,n) for(i=1;i<=n;i++)
#define szf sizeof()
#define sz size()
#define ln length()
#define mem(x,r) memset(x,r,sizeof(x))
#define inf 1000000000000
using namespace std;
using ll=long long;
const int N=1e5+4;

map<string,string>maap;

//////graph////////
vector<int>circle;
bool vis[N];
int parent[N];
int chk[N];
int color[N];
int tim[2][N];
int dis[N];
int position[N];
vector<int>adj[N];
vector<int>adj1[N];
//vector<pair<ll,ll>>adj[N];
vector<int>graph[N];
bool has_cycle;
int maxdis,maxnode,Totnode,depth=1;
bool ok;
queue<int>q;
stack<int>stk;
vector<int>solution;
int indegree[N];
int go[N];
int to[N];
map<int,int>mp1;

//////graph////////

/*** this solution will not work if freopen  terminal are open................
    If you close that freopen then its work here.
    But before submission you need to open freopen line when submit .text file***/

////calculate the path //////

//////////main function////////

int main()
{
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);
    Read_Fast;
    int t;
    // cin>>t;
    int cas=0;
    // while(t--)
    // {
    ll n,m,i,j,cnt1=0,cnt2=0,cnt=0,even=0,odd=0,len,k,r,l,z=0,x=0,y=0,flag=0,sum=0;
    ll a=0,b=0,c=0,d=0,ans=0,rem,quot,zero=0,fst=0,null=0,snd=0,lst=0,rone=0,one=0,pos=0,neg=0,mn=INT_MAX,mx=INT_MIN;

    char ch;

    ////Time/////
    int h1,h2,m1,m2,h;

    ////motion ////
    int velo1,velo2,ac1,ac2,time;

    /////Graph///
    int node,edge,u,v,cost;
    string str,str1="",str2="",str3="",strstore1="",strstore2="";

    //////Input Node ////
    int best,worst;
    cin>>str;
    n=str.size();
    cnt=-1;
    for(int i=0; i<n;)
    {
        if(str[i+1]!='/')
        {
            cnt++;
            for(int j=0; j<2*cnt; j++)
            {
                cout<<" ";
            }
            x++;
            cout<<str[i]<<str[i+1]<<str[i+2]<<endl;
            i+=3;
        }
        else
        {
            for(int j=0; j<2*cnt; j++)
            {
                cout<<" ";
            }
            cnt--;
            cout<<str[i]<<str[i+1]<<str[i+2]<<endl;
            i+=4;

        }

    }

    // }
    return 0;
///***###            ٱلْحَمْدُ لِلَّٰهِ          ###***///
}


#include <bits/stdc++.h>
#define M_PI    3.14159265358979323846  /* pi */
#define ff(i,s,n) for(int i=(s);i<(n);i++)
#define fr(i,s,n) for(int i=(n)-1;i>=(s);i--)
#define FF(i,s,n) for(int i=(s);i<=(n);i++)
#define Fr(i,s,n) for(int i=(n);i>=(s);i--)
#define FR(i,s,n) for(int i=(n);i>=(s);i--)
#define all(a) a.begin(),a.end()
#define tnm typename
#define invd inline int
#define templ1 template<tnm T>
#define btempl templ1 invd
#define ln prln()
#define sp prsp()
void init(){}
invd init(int n){
  char buff[100];
  sprintf(buff,"xx/%d.txt",n);
#ifndef ONLINE_JUDGE
    freopen(buff,"r",stdin);
#endif
}
using namespace std;typedef int64_t ll;typedef unsigned int uint;
invd scan(char&s){int c;while((c=getchar())=='\n'||c==' '||c=='\r');s=c;};
invd pr(ll i){printf("%" PRId64 ,i);}
invd scan(int&i){return scanf("%d",&i);}invd scan(double&i){return scanf("%lf",&i);}invd scan(ll&i){return scanf("%" PRId64 ,&i);}invd pr(const string&s){ff(i,0,s.size())putchar(s[i]);}
invd scan(string&s){int c;while((c=getchar())=='\n'||c==' '||c=='\r');do{switch(c){case'\n':case' ':case'\r':case EOF:return 0;default:s+=c;}}while((c=getchar())!=EOF);return s.size();};
invd scanln(string&s){int c;while((c=getchar())=='\n'||c==' '||c=='\r');do{switch(c){case'\n':case'\r':case EOF:return 0;default:s+=c;}}while((c=getchar())!=EOF);return s.size();};
invd pr(char c){putchar(c);};invd pr(const char*c){while(*c!=0)putchar(*c++);}
invd pr(int i){printf("%d",i);}invd pr(bool b){pr((int)b);}invd pr(double d){printf("%.9lf",d);}invd prln(){putchar('\n');}invd prsp(){putchar(' ');}
btempl scan(char*s){int c;while((c=getchar())){switch(c){case'\n':case'\r':case' ':break;default:*s++=c;}}*s=0;};
template<typename T>invd scan(T&arg) {return arg.scan();}
template<typename T, typename V> invd scan(pair<T,V>&a){scan(a.first),scan(a.second);}
btempl scan(vector<T>&v){for(T&t:v)scan(t);}btempl scan(T*a,int n){while(n--)scan(*a++);}
template<typename T, typename... Args>invd scan(T&first, Args (&... args)) {scan(first),scan(args...);}
template<typename T>invd pr(T arg) {arg.print();}
template<class A, class B> invd pr(pair<A,B> a){pr(a.first),sp,pr(a.second);}
btempl prsp(vector<T>&v){if(v.size())pr(v[0]);ff(i,1,v.size())sp,pr(v[i]);}btempl prsp(T*a,int n){while(n--)pr(*a++),sp;}btempl prln(vector<T>&v){for(const T&t:v)pr(t),ln;}
btempl pr(vector<T>&v){prsp(v);}
invd pr(size_t i){pr((ll)i);}
btempl prln(T*a,int n){while(n--)pr(*a++),ln;}btempl prln(vector<vector<T> >&v){for(vector<T>&t:v)prsp(t),ln;}
template<typename T, typename U>invd prln(T first, U second) {pr(first),ln,pr(second);}
template<typename T, typename... Args>invd prln(T first, Args... args) {pr(first),ln,prln(args...);}
template<typename T, typename... Args>invd pr(T first, Args... args) {pr(first),sp,pr(args...);}
templ1 vector<T>& operator+=(vector<T>& v,T x) {v.push_back(x);return v;}
templ1 vector<T>& operator--(vector<T>& v) {v.pop_back();return v;}templ1 vector<T>& operator--(vector<T>& v,int) {v.pop_back();return v;}
templ1 bool operator!(stack<T>&q) {return !q.empty();}templ1 stack<T>& operator+=(stack<T>& v,T x) {v.push(x);return v;}
templ1 T operator--(stack<T>& v) {v.pop();return v.top();}templ1 T operator--(stack<T>& v,int) {T t=v.top();v.pop();return t;}
templ1 bool operator!(queue<T>&q) {return !q.empty();}templ1 queue<T>& operator+=(queue<T>& v,T x) {v.push(x);return v;}
templ1 T operator--(queue<T>& v) {v.pop();return v.front();}templ1 T operator--(queue<T>& v,int) {T t=v.front();v.pop();return t;}
template<tnm T,tnm U>invd smax(T&a,U b){if(b>a)a=b;}template<tnm T,tnm U>invd smin(T&a,U b){if(b<a)a=b;}
template<tnm T,tnm U>inline T gcd(T a, U b){return __gcd(a,b);}typedef vector<int> vi;typedef vector<vi > vvi;typedef pair<int, int> pii;typedef pair<ll,ll> pll;
int getint(){
  int x;scan(x);return x;
}
#define gi getint()

typedef vector<pii > vpii;
typedef vector<ll > vll;
ll MOD = 1E9+7;
const ll linf=~(1ll<<63);
const int inf=~(1<<31);
const int sk = 1E9;

struct tag{
  string s;
  bool end;
  int scan(){
    end = 0,s.clear();
    int c;
    if((c=getchar())!='<')return 0;
    if((c=getchar())=='/')end=1,c=getchar();
    do s+=c;while((c=getchar())!='>');
    if(c=='/')end = 1,c=getchar();
    return 1;
  }
  int print(int l){
    ff(i,0,l)pr("  ");

    pr('<');if(end)pr('/');pr(s);
    pr('>');
  }
};

struct problem{

  void format_tag(tag&u,int level){
    u.print(level),ln;
    tag t={};
    while(scan(t)){
      if(t.end){
        t.print(level),ln;
        return;
      }else{
        format_tag(t,level+1);
      }
    }
  }

  int solve(){
    tag start={};
    while(scan(start)){
      format_tag(start,0);
    }

  }

  problem(){

  }

};

int main(){
  init(1);
  problem p = {};
  p.solve();
}


#include <bits/stdc++.h>
using namespace std;
string s;
vector <pair<int, bool> > a;
vector <int> b;

int main() {
    //freopen("125B.txt", "r", stdin);
    cin >> s;
    for (int i = 0; i < s.size(); i++)
    if (s[i] != '<' && s[i] != '>' && s[i] != '/') {
        bool k = false;
        if (s[i-1] == '/') k = true;
        a.push_back({s[i] - 'A', k});
    }
    b.resize(a.size());
    b[0] = 0;
    for (int i = 1; i < a.size(); i++) {
        if (!a[i].second) {
            if (a[i-1].second) b[i] = b[i-1];
            else b[i] = b[i-1] + 2;
        } else {
            if (a[i-1].second) b[i] = b[i-1] - 2;
            else b[i] = b[i-1];
        }
    }
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < b[i]; j++) cout << " ";
        if (a[i].second) {
            cout << "</" << char(a[i].first + 'A') << ">" << endl;
        } else {
            cout << "<" << char(a[i].first + 'A') << ">" << endl;
        }
    }
}


#include<bits/stdc++.h>
using namespace std;
string s;
int t=0;
int main(){
	cin>>s;
	for(int i=0;i<s.size();i++){
		if(s[i]=='<'||s[i]=='>')continue;
		if(s[i]=='/'){
			t--;
			for(int j=0;j<t*2;j++)cout<<" ";
			cout<<"<"<<s[i+1]<<">"<<endl;
			i++;
		}
		else{
			for(int j=0;j<t*2;j++)cout<<" ";
			cout<<"<"<<s[i]<<">"<<endl;
			t++;
		}
	}
	return 0;
}


#include <iostream>
#include<algorithm>
#include <stdio.h>
#include <string.h>
#include <cmath>
#include <stdlib.h>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
int main()
{
  string s;
   int l=0,x=0;
   cin>>s;
   for(int i=0;i<s.length();i++){
   	    if(s[i]=='>'){
		   if(s[i-2]=='/') x--;
   	    for(int j=1;j<=x*2;j++)
   	    cout<<' ';
   	    for(int j=l;j<=i;j++)
   	    cout<<s[j];
   	    cout<<endl;
   	    if(s[i-2]!='/') x++;

   	    l=i+1;
   	}
   }
}


#include <bits/stdc++.h>
#define F first
#define S second
#define mp make_pair

using namespace std;
char s[1009];
int main()
{
    string s;
    cin>>s;
    int n=s.length();
    stack<pair<string,int> > st;
    int i=0,c=0;
    while(i<n){
        string str="";
        if(s[i+1]=='/'){
            for(int j=i;j<i+4;j++)
                str+=s[j];
            //str+=s[i]+s[i+1]+s[i+2]+s[i+3];
            i+=4;
            for(int j=1;j<=2*st.top().S;j++)
                cout<<" ";
            cout<<str<<endl;
            c=st.top().S;
            st.pop();
        }
        else{
            for(int j=i;j<i+3;j++)
                str+=s[j];
            //str+=s[i]+s[i+1]+s[i+2];
            i+=3;
            st.push(mp(str,c));
            for(int j=1;j<=2*c;j++) cout<<" ";
            cout<<str<<endl;
            c++;
        }
    }
    return 0;
}


#include <bits/stdc++.h>
#define F first
#define S second
#define mp make_pair

using namespace std;
char s[1009];
int main()
{
    string s;
    cin>>s;
    int n=s.length();
    stack<pair<string,int> > st;
    int i=0,c=0;
    while(i<n){
        string str="";
        if(s[i+1]=='/'){
            for(int j=i;j<i+4;j++)
                str+=s[j];
            //str+=s[i]+s[i+1]+s[i+2]+s[i+3];
            i+=4;
            for(int j=1;j<=st.top().S;j++)
                cout<<" ";
            cout<<str<<endl;
            c=st.top().S;
            st.pop();
        }
        else{
            for(int j=i;j<i+3;j++)
                str+=s[j];
            //str+=s[i]+s[i+1]+s[i+2];
            i+=3;
            st.push(mp(str,c));
            for(int j=1;j<=c;j++) cout<<" ";
            cout<<str<<endl;
            c++;
        }
    }
    return 0;
}


#include<bits/stdc++.h>
#include<ext/numeric>
using namespace std;
using namespace __gnu_cxx;

#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(v)  (int)v.size()
#define UNVISITED -1
#define CLR(a,v) memset(a,v,sizeof a)
#define PC(x) __builtin_popcount(x)

typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> pll;

int dx[] = { 0, 0, 1, -1, -1, -1, 1, 1 };
int dy[] = { 1, -1, 0, 0, 1, -1, 1, -1 };

int main() {
#ifndef ONLINE_JUDGE
	freopen("in.txt", "rt", stdin);
//	freopen("out.txt", "wt", stdout);
#endif
	string s;
	cin >> s;
	stack<char> st;
	int n = sz(s);
	for (int i = 1; i < n; i += 3)
		if (islower(s[i])) {
			for (int j = 0; j < (sz(st) << 1); ++j)
				cout << ' ';
			cout << "<" << s[i] << ">\n";
			st.push(s[i]);
		} else {
			st.pop();
			++i;
			for (int j = 0; j < (sz(st) << 1); ++j)
				cout << ' ';
			cout << "</" << s[i] << ">\n";
		}
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define gcd __gcd
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vvi vector< vector<int> >
#define fr(j, n)for(int i=j; i<n; i++)
#define scan(cr)for(auto &it:cr)cin >> it
#define all(cr)cr.begin(), cr.end()
#define sz(cr)cr.size()
#define Test() ll t, cases=0; for(cin >> t; t>0; t--)
ll lcm(ll a, ll b){ return a/gcd(a, b) * b; }

#define debug(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); deb(_it, args); }
void deb(istream_iterator<string> it) {cout<<endl;}
template<typename T, typename... Args>
void deb(istream_iterator<string> it, T a, Args... args) {
    cerr << *it << " = " << a << ",   ";
    deb(++it, args...);
}
template<class A>void print(A &v){ for(auto u:v)cout << u << " "; }
template<class A>void _print(A &v){ for(auto u:v)cout << u.ff << " " << u.ss << '\n'; }
#define nl cout << '\n'
#define occ cout << "occ!!\n";
int coins[] = {0, 0, 0};
const int N = 100, INF = INT_MAX;
static int steps = 0;

int arra[5001];

int main()
{
	string s;
	cin >> s;
	int h=0;
	for(int i=0; i<sz(s); i++){
		if(s[i]=='>' && s[i-2]=='<'){
			for(int j=1; j<=2*h; j++)cout << " ";
			cout << s.substr(i-2, 3) << '\n';
			h++;
		}else if(s[i]=='>' && s[i-2]=='/'){
			h--;
			for(int j=1; j<=2*h; j++)cout << " ";
			cout << s.substr(i-3, 4) << '\n';
		}
	}
    return 0;
}


#include<bits/stdc++.h>
#include<unordered_set>
using namespace std;
#define sc(x) scanf("%d",&x)
#define sc2(x,y) scanf("%d%d",&x, &y)
#define sc3(x,y,z) scanf("%d%d%d",&x, &y, &z)
#define pr(a) printf("%d\n",a)
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define ll long long
#define F first
#define S second
#define inf INT_MAX
const int N = 1e5+5;
int m, n, x, y, q, k, ans;
void sp(int i){
	i *= 2;
	while (i--)printf(" ");
}
int main(){
#ifndef ONLINE_JUDGE
	freopen("myFile.txt", "r", stdin);
#endif
	vector<string>v;
	string s,r="";
	cin >> s;
	for (int i = 0; i < s.size(); i++){
		r += s[i];
		x = r.size();
		if (s[i] == '>')v.push_back(r), r = "";
	}
	x = 0;
	n = v.size();
	for (int i = 0; i < n; i++){
		if (v[i][1] != '/'){
			cout << v[i] << endl;
			if (i + 1<n && v[i][1] == v[i + 1][2])sp(x);
			else sp(++x);
		}
		else if (i + 1 < n&&v[i][1] == '/'&&v[i + 1][1] != '/'){
			cout << v[i] << endl; sp(x);
		}
		else{
			cout << v[i] << endl;
			if (i+1<n &&v[i][1] == v[i + 1][2])sp(max(x, 0));
			else sp(max(--x,0));
		}
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
string s;
queue<char> q;
int cnt=0;
int a[26];
int main()
{
    cin>>s;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]<='z'&&s[i]>='a')
            q.push(s[i]);
    }
    while(!q.empty())
    {
        if(!a[q.front()-'a'])
        {
            for(int i=0;i<cnt;i++)
                printf("  ");
            cnt++;
            printf("<%c>\n",q.front());
            a[q.front()-'a']=1;
            q.pop();
        }
        else if(a[q.front()-'a'])
        {
            cnt--;
            for(int i=0;i<cnt;i++)
                printf("  ");
            a[q.front()-'a']=0;
            printf("</%c>\n",q.front());
            q.pop();
        }
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
string s;
queue<char> q;
int cnt=0;
int a[26];
int main()
{
    cin>>s;
    for(int i=1;i<s.length();i++)
    {
        if(s[i]<='z'&&s[i]>='a'&&s[i-1]=='/')
            q.push(s[i]-32);
        else if(s[i]<='z'&&s[i]>='a')
            q.push(s[i]);

    }
    while(!q.empty())
    {
        if(q.front()<='z'&&q.front()>='a')
        {
            for(int i=0;i<cnt;i++)
                printf("  ");
            cnt++;
            printf("<%c>\n",q.front());
            q.pop();
        }
        else if(q.front()<='Z'&&q.front()>='A')
        {
            cnt--;
            for(int i=0;i<cnt;i++)
                printf("  ");
            printf("</%c>\n",q.front()+32);
            q.pop();
        }
    }
    return 0;
}


#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;

template <typename T>
T next_int() {
	T x = 0, p = 1;
	char ch;
	do { ch = getchar(); } while(ch <= ' ');
	if(ch == '-') {
		p = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		x = x * 10 + (ch - '0');
		ch = getchar();
	}
	return p * x;
}

const int max_n = (int)1e5 + 228;
const int max_int = (int)1e9 + 228;

int main() {
//	freopen(".in", "r", stdin);
//	freopen(".out", "w", stdout);

	string a;
	cin >> a;

	string b = "";
	int kek = 0;
	for(int i = 0; i < a.size(); i++) {
		if(a[i] == '>') {
			b += '>';
			if(b[1] == '/') kek--;
			for(int i = 0; i < kek; i++) cout << "  ";
			if(b[1] != '/') kek++;
			cout << b << "\n";
			b = "";
		} else b += a[i];
	}
}


#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<iostream>
using namespace std;
typedef __int64 LL;

#define mst(a) memset(a,0,sizeof(a));
#define bug(a) cout<<#a<<" = "<<a<<endl;
#define pos(a) getchar();
#define isc(a) int a;scanf("%d",&a);
#define pr(a)  cout<<a<<endl;

char s[1010];
int a[1010];
void print(int sp,char c,int flag){
	for(int i = 0 ; i <sp;i++){
		cout<<" ";
	}
	if(flag){
		cout<<"</";
	}else{
		cout<<"<";
	}
	cout<<c<<">"<<endl;
}
int main(){
	mst(a);
	scanf("%s",s);
	int space = 0;
	for(int i = 0 ; s[i] ; i ++){
		if(s[i]=='<'||s[i]=='>'){
			continue;
		}
		if(s[i]=='/'){
			space-=2;
			print(space,s[i+1],1);
			i++;

		}else{
			print(space,s[i],0);
			i++;
			space+=2;
		}
	}
	return 0;
}


#include <bits/stdc++.h>

using namespace std;

int n, a, b[10000005], mx=-99999999, s1, s2, c, ct;
string s;
stack <char> st;
map <char, int> o;
char x;

int main()
{
    cin >> s;
    for (int i=0;i<s.size();i++)
    {
        string d="";
        int a=0;
        if (s[i]=='<')
        {
            while (s[i]!='>')
            {
                d+=s[i];
                ++i;
            }
        }
        d+='>';
        for (int j=0;j<d.size();j++)
        {
            if (d[j]=='/')
                a=1;
        }
        if (a==0)
            x=d[1];
        else
            x=d[2];
        if (a==0)
        {
            for (int j=1;j<=c*2;j++)
            {
                cout << " ";
            }
            cout << d << endl;
            ct++;
            b[ct]=c;
            c++;
        }
        else
        {
            for (int j=1;j<=b[ct]*2;j++)
            {
                cout << " ";
            }
            cout << d << endl;
            ct--;
            c--;
        }
    }
}


#include<iostream>
#include<cstdio>
#include<string>
#include<stack>

using namespace std;

string str;

int main() {
    cin >> str;
    int len = str.length();
    int h = 0;
    for(int i = 0;i < len;) {
        if(str[i] == '<' && str[i + 1] != '/' && str[i + 2] == '>') {
            for(int j = 1;j <= 2 * h;j++) {
                printf(" ");
            }
            printf("%c%c%c\n", str[i],str[i + 1],str[i + 2]);
            i += 3;
            h++;
        }
        else {
            h--;
            for(int j = 1;j <= 2 * h;j++) {
                printf(" ");
            }
            printf("%c%c%c%c\n", str[i],str[i + 1],str[i + 2],str[i + 3]);
            i += 4;
        }
    }
}


#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#define N 1020
using namespace std;

char s[N];
bool v[N];

int main(void)
{
    int i, j, k;

    scanf("%s", s);

    for(i = j = 0; s[i]; i += 3)
    {
        if(s[i + 1] == '/')
            -- j;
        for(k = 0; k < (j << 1); k ++)
            putchar(' ');
        putchar('<');
        if(isalpha(s[i + 1]))
        {
            ++ j;
            putchar(s[i + 1]);
            v[s[i + 1]] = true;
        }
        else
        {
            putchar('/');
            putchar(s[++ i + 1]);
            v[s[i + 1]] = false;
        }
        puts(">");
    }

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

template<typename T>
void sci(T& t) {
    cin >> t;
}

template<typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
    sci(t);
    sci(ts...);
};

#define scid(vars...) int vars; sci(vars)
#define scidl(vars...) lint vars; sci(vars)
#define scidd(vars...) double vars; sci(vars)
#define scids(vars...) string vars; sci(vars)

typedef long long lint;

void prsp(int h) {
    for (int i = 0; i < h; i++) {
        cout << "  ";
    }
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    scids(s);
    int ch = 0;
    for (int i = 0; i < s.size(); i++) {
        if (s[i + 1] != '/') {
            prsp(ch);
            cout << s.substr(i, 3) << "\n";
            ch++;
            i += 2;
        } else {
            --ch;
            prsp(ch);
            cout << s.substr(i, 4) << "\n";
            i += 3;
        }
    }

    return 0;
}


#include <bits/stdc++.h>
#define T top()
#define P pop()
#define E end()
#define S size()
#define B begin()
#define X first
#define Y second
#define RE resize
#define mP make_pair
#define pB push_back
#define ST setprecision
typedef long long ll;
typedef long double lb;
using namespace std;
int main()
{
	ios_base::sync_with_stdio(false);
	int s=0;
	string a,t;
	vector <string> b;
	cin>>a;
	for(int i=0;i<a.S;i++)
		if(a[i]=='<')
		{
			i++;
			t="";
			while(a[i]!='>')
			{
				t+=a[i];
				i++;
			}
			b.pB(t);
		}
	for(int i=0;i<b.S;i++)
	{
		if(b[i][0]=='/')
		{
			s--;
			for(int j=0;j<s;j++)
				cout<<"  ";
		}
		else
		{
			for(int j=0;j<s;j++)
                                cout<<"  ";
			s++;
		}
		cout<<'<'<<b[i]<<'>'<<endl;
	}
	return 0;
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
#define IOS ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0)
inline int in(){int32_t x ; scanf("%d",&x) ; return x ;}
inline long long lin(){long long x ; scanf("%lld",&x) ; return x;}
const int maxn = 200 + 10;
const int inf = 1e18 ;
int32_t main()
{
	string s ; cin >> s;
	int h = 0;
	for (int i = 0 ; i < s.size() ; i ++)
	{
		if (s[i] == '<')
		{
			if (s[i + 1] == '/')
			{
				h -= 1;
				for (int pt = 0 ; pt < 2 * h ; pt ++) cout << " ";
				cout << s.substr(i,3);

				cout << "\n";
			}
			else
			{
				for (int pt = 0 ; pt < 2 * h ; pt ++) cout << " ";
				cout << s.substr(i,3);
				h += 1;

				cout <<"\n";
			}
		}
	}
}


#include <bits/stdc++.h>
using namespace std;
#define int long long
#define IOS ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0)
inline int in(){int32_t x ; scanf("%d",&x) ; return x ;}
inline long long lin(){long long x ; scanf("%lld",&x) ; return x;}
const int maxn = 200 + 10;
const int inf = 1e18 ;
int32_t main()
{
	string s ; cin >> s;
	int h = 0;
	for (int i = 0 ; i < s.size() ; i ++)
	{
		if (s[i] == '<')
		{
			if (s[i + 1] == '/')
			{
				h -= 1;
				for (int pt = 0 ; pt < 2 * h ; pt ++) cout << " ";
				cout << s.substr(i,4);

				cout << "\n";
			}
			else
			{
				for (int pt = 0 ; pt < 2 * h ; pt ++) cout << " ";
				cout << s.substr(i,3);
				h += 1;

				cout <<"\n";
			}
		}
	}
}


#include<iostream>
#include<string.h>

using namespace std;

int main()
{
    string s;
    cin>>s;int flag=0;string space;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]=='<')
        {flag=1;continue;}

        if(flag==1)
        {
        	char ch;int f=0;
            ch=s[i];
            if(ch=='/')
            {
                char c=s[i+1];int l=space.length();
                space.resize(l-2);
                cout<<space<<"</"<<c<<">\n";flag=0;
                l=space.length();

                //if(space!="")
                //space.resize(l-2);

                i+=1;continue;
            }
            else
            {

                char c=s[i];
                cout<<space<<"<"<<c<<">\n";flag=0;
                i++;
                space.push_back(' ');space.push_back(' ');f=1;
                continue;
            }

        }

    }

}


#include<iostream>
#include<string.h>

using namespace std;

int main()
{
    string s;
    cin>>s;int flag=0;string space;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]=='<')
        {flag=1;continue;}

        if(flag==1)
        {
        	char ch;
            ch=s[i];
            if(ch=='/')
            {
                char c=s[i+1];
                cout<<space<<"</"<<c<<">\n";flag=0;
                int l=space.length();
                if(l>1)
                space.resize(l-2);
                i+=1;continue;
            }
            else
            {
                if(i!=1)
                space.push_back(' ');space.push_back(' ');

                char c=s[i];
                cout<<space<<"<"<<c<<">\n";flag=0;
                i++;continue;
            }

        }

    }

}


#include<iostream>
#include<string.h>

using namespace std;

int main()
{
    string s;
    cin>>s;int flag=0;string space;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]=='<')
        {flag=1;continue;}

        if(flag==1)
        {
        	char ch;
            ch=s[i];
            if(ch=='/')
            {
                char c=s[i+1];
                cout<<space<<"</"<<c<<">\n";flag=0;
                int l=space.length();
                if(l>1)
                space.resize(l-2);
                i+=1;continue;
            }
            else
            {
                if(i!=1)
                {space.push_back(' ');space.push_back(' ');}

                char c=s[i];
                cout<<space<<"<"<<c<<">\n";flag=0;
                i++;continue;
            }

        }

    }

}


/*
 * 125B. Simple XML.cpp
 *
 *  Created on: Apr 13, 2016
 *      Author: Osama Hatem
 */

#include <bits/stdtr1c++.h>
#include <ext/numeric>

using namespace std;

int main() {
#ifndef ONLINE_JUDGE
	freopen("in.in", "r", stdin);
//	freopen("out.out", "w", stdout);
#endif

	char in[1005];
	scanf("%s", in);
	int sp = 0, idx = 0, len = strlen(in);
	string ans;
	while (idx < len) {
		bool close = 0;
		string temp;
		while (in[idx] != '>') {
			if (in[idx] == '/')
				close = 1;
			temp += in[idx++];
		}
		temp += in[idx++];
		if (close)
			sp -= 2;
		for (int i = 0; i < sp; i++)
			ans += " ";
		if (!close)
			sp += 2;
		ans += temp + "\n";
	}
	printf("%s", ans.c_str());
	return 0;
}


#include <iostream>
using namespace std;void f(int s){while(s--)cout<<" ";}main(){string j;int i=0,s=0;cin>>j;while(i<j.length()){if(j[i+1]=='/'){s-=2;f(s);cout << j.substr(i,4) << endl;i+=4;}else{f(s);cout<<j.substr(i,3)<<endl;i+=3;s+=2;}}}


#include<bits/stdc++.h>
using namespace std;

bool ppair(string s1, string s2)
{
	if (s1.size() != 3 || s2.size() != 4) return false;
	if (s1[1] != s2[2]) return false;
	return true;
}

int main()
{
	string s;
	cin >> s;
	string x = "";
	stack<string> st;
	for (int i = 0; i < s.size(); i++)
	{
		if (s[i] != '>')
		{
			x += s[i];
			continue;
		}
		x += s[i];
		if (st.empty())
		{
			for (int j = 0; j < (int)st.size() * 2; j++) cout << ' ';
			cout << x << '\n';
			st.push(x);
			x = "";
			continue;
		}
		if (ppair(st.top(), x))
		{
			st.pop();
			for (int j = 0; j < (int)st.size() * 2; j++) cout << ' ';
			cout << x << '\n';
			x = "";
			continue;
		}
		for (int j = 0; j < (int)st.size() * 2; j++) cout << ' ';
		cout << x << '\n';
		st.push(x);
		x = "";
		continue;
	}
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	int space=0;
	string a;cin>>a;
	for (int i = 0; i < a.length(); i++){
		if(a[i]=='>' || (a[i]>='a' && a[i]<='z') || a[i]=='/'){
			cout<<a[i];
		}
		else{
			if(a[i+1]=='/'){
			    space-=2;
			}
			if(i){
			    cout<<"\n";
			}
			if(i)
			for (int j = 0; j < space; j++){
				cout<<" ";
			}
			if(a[i+1]!='/'){
			    space+=2;
			}
			cout<<"<";
		}
	}
	return 0;
}


#include <iostream>
#include <string>

using namespace std;

long position;

int main()
{
    string code;
    cin >> code;
    for(long i = 0; i < code.length(); i++)
    {
        if(code[i] != '<' && code[i] != '>')
        {
            if(code[i-1] == '/')
            {
            position --;
             for(long j = 0; j < position; j ++)
              cout << "  ";
             cout << code[i-2] << code[i-1] << code[i] << code[i+1] << endl;
             //probels.remove(probels.length()-1, probels.length()-2);

            }
            else if(code[i-1] == '<' && code[i] != '/'){
                for(long j = 0; j < position; j++)
                  cout << "  ";
                cout << code[i-1] << code[i] << code[i+1] << endl;
                position ++;
            }
        }
    }
    return 0;
}


//#include <bits/stdc++.h>
#include <cstdio>
#include <numeric>
#include <iostream>
#include <vector>
#include <set>
#include <cstring>
#include <string>
#include <map>
#include <cmath>
#include<stack>
#include <ctime>
#include <algorithm>
#include <bitset>
#include<stdio.h>
#include <queue>
#include <sstream>
#include <deque>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

void Speed(){
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	//freopen("inp.txt", "r", stdin);
	//freopen("outp.txt", "w", stdout);
}
//==============================================================================
int main()
{
	Speed();
	string s;
	cin >> s;
	int h = 0;
	for (int i = 0; i < s.length();)
	{
		string tmp = "";
		if (s[i + 1] == '/')
		{
			tmp = s.substr(i, 4);
			i += 4;
			h--;
			for (int j = 0; j < h * 2; j++)cout << " ";
			cout << tmp << endl;;
		}
		else
		{
			tmp = s.substr(i, 3);
			i += 3;
			for (int j = 0; j < h * 2; j++)cout << " ";
			cout << tmp << endl;
			h++;
		}

	}
	return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;
int main(){
    string str;
    cin>>str;
    for(int i = 0, space = 0; str[i]; i++){
        if(str[i] != '<')
            continue;
        if(str[i + 1] == '/')
            space -= 2;
        for(int i = 0; i < space; i++)
            cout<<' ';
        for(int j = 0; j < 3 + (str[i + 1] == '/'); j++)
            cout<<str[i + j];
        cout<<endl;
        if(str[i + 1] != '/')
            space += 2;
    }
    return 0;
}


#include<stdio.h>
#include<iostream>
using namespace std;
int main(){
    string str;
    cin>>str;
    for(int i = 0, space = 0; str[i]; i++){
        if(str[i] != '<')
            continue;
        if(str[i + 1] == '/')
            space--;
        for(int i = 0; i < space; i++)
            cout<<' ';
        for(int j = 0; j < 3 + (str[i + 1] == '/'); j++)
            cout<<str[i + j];
        cout<<endl;
        if(str[i + 1] != '/')
            space++;
    }
    return 0;
}


#include <bits/stdc++.h>
using namespace std;
vector <string> tags;
vector <int> spaces;
int main()
{
    string s;
    cin >> s;
    string temp;
    int levels = 0;
    for(int i = 0;i < s.size();i++)
    {
        if(s[i] == '<')
        {
            temp.clear();
            temp += s[i];
        }
        else if(s[i] == '>')
        {
            temp += s[i];
            tags.push_back(temp);
        }
        else
        {
            temp += s[i];
        }
    }
    spaces.resize(tags.size());
    for(int i = 0;i < tags.size();i++)
    {
        if(tags[i][1] != '/')
        {
            if(i)
                levels++;
            spaces[i] = 2 * levels;
        }
        else
        {
            spaces[i] = 2 * levels;
            levels--;
        }
    }
//    for(int i = 0; i < tags.size();i++)
//        cout << tags[i] << " " << spaces[i] <<endl;
    for(int i = 0;i < tags.size();i++)
    {
        for(int j = 0;j < spaces[i];j++)
            cout << " ";
        cout << tags[i] <<endl;
    }
    return 0;
}