// Arup Guha
// 3/30/2014
// Solution to 2014 Chicago Invitational (NAIPC) Problem H: Reconnaissance

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

public class reconnaissance {

	public static long[][] planes;
	public static int n;

	public static void main(String[] args) throws Exception {

		BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
		n = Integer.parseInt(stdin.readLine().trim());

		while (n != 0) {

			// Read in each plane.
			planes = new long[n][2];
			for (int i=0; i<n; i++) {
				StringTokenizer tok = new StringTokenizer(stdin.readLine());
				planes[i][0] = Long.parseLong(tok.nextToken());
				planes[i][1] = Long.parseLong(tok.nextToken());
			}

			// Solve and go to the next case.
			System.out.printf("%.2f\n", solve()+1e-10);
			n = Integer.parseInt(stdin.readLine().trim());
		}
	}

	// Does a ternary search...
	public static double solve() {

		double best = range(0);

		// Simple base case.
		if (bestNow()) return best;

		// Safe bounds for the ternary search.
		double low = 0, high = 1000000;

		// A for loop ensures we always finish (sometimes a while with floating pt error = infinite loop)
		// 2 iterations divides range in more than 2, so this is at least as good as (high-low)/2^50 for precision.
		for (int i=0; i<100; i++) {
		
			double lowThird = (2*low+high)/3;
			double highThird = (low+2*high)/3;

			// Update the appropriate bound.
			if (range(lowThird) > range(highThird)) 
				low = lowThird;
			else 
				high = highThird;
		}

		return range(low);
	}

	public static boolean bestNow() {

		// Find min and max at that start...
		int mini = 0, maxi = 0;
		for (int i=1; i<n; i++) {

			if ((planes[i][0] < planes[mini][0]) ||
			    (planes[i][0] == planes[mini][0] && planes[i][1] < planes[mini][1]))
			   	mini = i;
			if ((planes[i][0] > planes[maxi][0]) ||
			    (planes[i][0] == planes[maxi][0] && planes[i][1] > planes[maxi][1]))
				maxi = i;
		}

		// See if the outer planes are continuing to move farther apart.
		return planes[maxi][1] >= planes[mini][1];
	}

	// Evaluate all planes and time t and return the different between the min and max locations.
	public static double range(double t) {

		double min = planes[0][0] + t*planes[0][1];
		double max = min;

		for (int i=1; i<n; i++) {
			double cur = planes[i][0] + t*planes[i][1];
			if (cur < min) min = cur;
			if (cur > max) max = cur;
		}

		return max-min;
	}
}