#include <bits/stdc++.h>
//#include <GL/freeglut.h>
//#include <GL/gl.h>
//#include <GL/glu.h>
//#include <GL/glut.h>

using namespace std;


void draw_line(double  xa, double ya, double xb, double yb)
{
	double dx1,dy1;
	double x, y;
	double dx, dy;
	int i;

	dx = xb-xa;
	dy = yb-ya;
	x = xa;
	y = ya;
	dx1 = dx / 10000.0;
	dy1 = dy / 10000.0;

	//cout << xa << " " << ya << " " <<  endl;
	for (i = 0; i < 10000; i++) {
		x = x +  dx1;
		y  = y + dy1;
	//	glVertex3f(x, y, 0.1);
	}
}

double m1, m2;
double n1, n2;
double o1, o2;
double p1, p2;

void modify(double xa, double ya, double xb, double yb)
{
	double za, zb;
	double p = 0.1;
	double x1, y1, z1, x2, y2, z2, th;
	th =  3.14 / 2 - atan(p) ;
//	theta = -theta;
	
	x2 = xb;
	y2 = yb * cos(th);
	z2 = yb * sin(th);

	x1 = xa;
	y1 = ya * cos(th);
	z1 = ya * sin(th);

	za = z1 + sqrt(1.0100);
	zb = z2 + sqrt(1.0100);

	xa = (xa / za) * 10;
	ya = (y1 / za) * 10;

	xb = (xb / zb) * 10;
	yb = (y2 / zb) * 10;

	cout << xa << " " << ya  << endl;
	draw_line(xa, ya, xb, yb );
}

void func() {
	
	modify(m1, m2, n1, n2);
	modify(n1, n2, o1, o2);
	modify(o1, o2, p1, p2);
	modify(p1, p2, m1, m2);

	modify(-0.050, 0.0, -0.050,0.500);

	modify(-0.150,0.0, -0.500,0.400);

	modify(-0.500,0.400, -0.100,0.700);

	modify(-0.050, 0.0, -0.400,0.400);

	modify(-0.400, 0.400 ,-0.100,0.600);

	modify(0.050, 0.0, 0.050,0.500);

        modify(0.150,0.0, 0.500,0.400);

        modify(0.500,0.400, 0.100,0.700);

        modify(0.050, 0.0, 0.400,0.400);

        modify(0.400, 0.400 ,0.100,0.600);

}

struct Queue
{
    int front, rear, size;
    unsigned capacity;
    int* array;
};
 
struct Queue* createQueue(unsigned capacity)
{
    struct Queue* queue = (struct Queue*) malloc(sizeof(struct Queue));
    queue->capacity = capacity;
    queue->front = queue->size = 0; 
    queue->rear = capacity - 1;  
    queue->array = (int*) malloc(queue->capacity * sizeof(int));
    return queue;
}
 

int isFull(struct Queue* queue)
{  return (queue->size == queue->capacity);  }
 
int isEmpty(struct Queue* queue)
{  return (queue->size == 0); }
 
void enqueue(struct Queue* queue, int item)
{
    if (isFull(queue))
        return;
    queue->rear = (queue->rear + 1)%queue->capacity;
    queue->array[queue->rear] = item;
    queue->size = queue->size + 1;
    printf("%d enqueued to queue\n", item);
}
 
int dequeue(struct Queue* queue)
{
    if (isEmpty(queue))
        return INT_MIN;
    int item = queue->array[queue->front];
    queue->front = (queue->front + 1)%queue->capacity;
    queue->size = queue->size - 1;
    return item;
}
 
int front(struct Queue* queue)
{
    if (isEmpty(queue))
        return INT_MIN;
    return queue->array[queue->front];
}
 
int rear(struct Queue* queue)
{
    if (isEmpty(queue))
        return INT_MIN;
    return queue->array[queue->rear];
}
 


int main(int argc, char ** argv)
{
	m1 =  -0.100; m2 = 0.700;
	n1 = -0.100; n2 =0.500;
	o1 = 0.100; o2 = 0.700;
	p1 = 0.100; p2 =0.500;
	
	func();

	return 0;
}