// Arup Guha
// 8/2/2026
// Solution to 1989 UCF HS Programming Contest Problem: Room Service

/*** This problem is quite hard, harder than it looks! ***/
/*** I need this verified by someone else. ***/

import java.util.*;

public class sheet {
	
	final public static double SCALE = 100.0;
	
	public static void main(String[] args) {
	
		Scanner stdin = new Scanner(System.in);	
		while (stdin.hasNext()) {
		
			// I use this scale idea for precision sometimes.
			double x = SCALE*stdin.nextDouble();
			double y = SCALE*stdin.nextDouble();
			
			/*** Today we would use a tolerance checker, probably do absolute or
			     relative error of 0.000001. So instead of doing 3 decimal places
				 I'll do this instead.
			***/
			
			// Note: I assume x>=y to reduce case work.
			double area = solve(Math.max(x,y), Math.min(x,y));
			System.out.println("Area = "+(area/SCALE/SCALE));
		}
	}
	
	// Returns the area for folding to (x, y) on a 100 by 100 sheet.
	public static double solve(double x, double y) {
	
		// Degenerate case.
		if (Math.abs(SCALE-x) < 1e-9 && Math.abs(SCALE-y) < 1e-9) return SCALE*SCALE;
		
		// Rectangle case.
		if (Math.abs(SCALE-x) < 1e-9) return SCALE*(SCALE+y)/2;
		
		/*** if we get here y <= x < 100 ***/
		
		double midX = (SCALE+x)/2;
		double midY = (SCALE+y)/2;
		double dx = SCALE-x;
		double dy = SCALE-y;
		
		// What I plug in to lambda to intersect with line x = SCALE.
		double lambda = (SCALE-midX)/dy;
		double yRight = midY - lambda*dx;
		
		// Get y value for intersection with x = 0.
		double lambda2 = -midX/dy;
		double yLeft = midY - lambda2*dx;
		
		// Get x value for intersection with y = SCALE.
		double lambda3 = (midY-SCALE)/dx;
		double topX = midX + lambda3*dy;
		
		// Harder case - new area formed by triangle left of x = 0.
		if (yLeft < SCALE) {
		
			// Trapezoid area.
			double areaTrap = (yLeft+yRight)*SCALE/2;
			
			// Delta for line from bottom folded point to apex of line of symmetry.
			double newdx = topX-x;
			double newdy = SCALE-y;
			double sigma = -x/newdx;
			
			// The point (0, lowerYLeft) is where the folded paper hits the left side 
			// of the original paper.
			double lowerYLeft = y + sigma*newdy;
			
			// Now getting the third vertex of the triangle overhang.
			
			// Rewrite vector as unit vector.
			double mag = Math.sqrt(newdx*newdx+ newdy*newdy);
			newdx /= mag;
			newdy /= mag;
			
			// This is the third point of the triangle.
			double thirdX = x + SCALE*newdx;
			double thirdY = y + SCALE*newdy;
			
			// These are two legs of the right triangle overhang.
			double d1 = dist(thirdX, thirdY, 0, lowerYLeft);
			double d2 = dist(thirdX, thirdY, 0, yLeft);
			
			// This should be the final area.
			return areaTrap + d1*d2/2;
		}
		
		// Easier case - Just lose triangle area.
		else {			
			// Just subtract out the area of the folded triangle.
			return SCALE*SCALE - .5*(SCALE-topX)*(SCALE-yRight);
		}
	}
	
	public static double dist(double x1, double y1, double x2, double y2) {
		return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
	}
}