#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const double E2 = 1.355, PI = 3.1415926535, EPS = 0.00001;

struct Point
{
	int x, y;
	
	double distance(const Point &p) const
	{
		return sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
	}
} *s;

struct Vector
{
	double x, y, length;
	
	void calculate_length()
	{
		length = sqrt(x * x + y * y);
	}
	
	double angle(const Vector &v)
	{
		return acos((x * v.x + y * v.y) / (length * v.length));
	}
	
	void rotate(double angle)
	{
		double sin_angle = sin(angle), cos_angle = cos(angle), temp_x = x;
		
		x = x * cos_angle - y * sin_angle;
		y = temp_x * sin_angle + y * cos_angle;
	}
};

struct PointComparator
{
	Point p0;
	
	PointComparator(const Point &p)
	{
		p0 = p;
	}
	
	bool operator()(const Point &p1, const Point &p2) const
	{
		return (p0.x - p1.x) * p0.distance(p2) < (p0.x - p2.x) * p0.distance(p1);
	}
};

bool convex(const Point &p1, const Point &p2, const Point &p3)
{
	return (p2.x - p1.x) * (p3.y - p2.y) > (p3.x - p2.x) * (p2.y - p1.y);
}

struct Solution
{
	int n, cost, x, stack_pos;
	double alpha, result;
	Point *points;
	char **transformations;
	
	bool operator<(const Solution &s) const
	{
		return result < s.result;
	}
	
	double width()
	{
		int i, min_i = 0, top = 0, pos1 = 0, pos2 = 1;
		double current_alpha = 0, angle1, angle2, min_angle, current_dist, dist = 1000000;
		Point *stack = new Point[n];
		Vector caliper1, caliper2, edge1, edge2;
		caliper1.x = 1;
		caliper1.y = 0;
		caliper1.length = 1;
		caliper2.x = -1;
		caliper2.y = 0;
		caliper2.length = 1;
		
		for (i = 1; i < n; i++)
			if (points[min_i].y > points[i].y)
				min_i = i;
		
		swap(points[0], points[min_i]);
		sort(points + 1, points + n, PointComparator(points[0]));
		
		for (i = 0; i < n; i++)
		{
			while (top > 1 && !convex(stack[top - 2], stack[top - 1], points[i]))
				top--;
			stack[top++] = points[i];
		}
		
		for(i = 2; i < top; i++)
			if (stack[pos2].y < stack[i].y)
				pos2 = i;
				
		while(current_alpha < PI)
		{
		   	edge1.x = stack[(pos1 + 1) % top].x - stack[pos1].x;
		   	edge1.y = stack[(pos1 + 1) % top].y - stack[pos1].y;
		   	edge1.calculate_length();
		   	edge2.x = stack[(pos2 + 1) % top].x - stack[pos2].x;
		   	edge2.y = stack[(pos2 + 1) % top].y - stack[pos2].y;
		   	edge2.calculate_length();
		   	angle1 = edge1.angle(caliper1);
		   	angle2 = edge2.angle(caliper2);
		   	min_angle = min(angle1, angle2);
		   			   
			caliper1.rotate(min_angle);
		   	caliper2.rotate(min_angle);
		   			   	
			if(angle1 < angle2)
			{
				pos1 = (pos1 + 1) % top;
		     	current_dist = abs(caliper1.x * stack[pos1].y - caliper1.y * stack[pos1].x - caliper1.x * stack[pos2].y + caliper1.y * stack[pos2].x);
			}
		   	else
		   	{
		     	pos2 = (pos2 + 1) % top;
		     	current_dist = abs(caliper2.x * stack[pos2].y - caliper2.y * stack[pos2].x - caliper2.x * stack[pos1].y + caliper2.y * stack[pos1].x);
			}
			
			current_alpha += min_angle;
					   			
			if(dist > current_dist)
			{
				dist = current_dist;
				alpha = current_alpha;
			}
		}
		
		delete[] stack;		
		
		return dist;
	}
	
	void calculate_result()
	{
		double dist = width();
		result = 25 * (dist + 0.01 * pow(E2, x) * (dist + 1)) + 0.02 * cost * (dist + 1);
	}
};

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

	int i, m, c = 1;
	Solution *solutions = new Solution[20];
	
	scanf("%d", &solutions[0].n);
	
	solutions[0].cost = 0;
	solutions[0].x = 0;
	solutions[0].stack_pos = 0;
	solutions[0].points = new Point[solutions[0].n];
	for(i = 0; i < solutions[0].n; i++)
		scanf("%d%d", &solutions[0].points[i].x, &solutions[0].points[i].y);
	scanf("%d", &m);
	s = new Point[m];

	for(i = 0; i < m; i++)
		scanf("%d%d", &s[i].x, &s[i].y);
	solutions[0].calculate_result();
	
	printf("0\n%.6lf\n", solutions[0].alpha);
	
	delete[] solutions;
	delete[] s;
	
	return 0;
}