import std.stdio;

import std.math;

struct CoordXY
{
	double x, y;
	static CoordXY opCall(double _x, double _y) {
		CoordXY result;
		result.x=_x;
		result.y=_y;
		return result;
	}

	public double dist(CoordXY other)
	{
		double dx=x-other.x;
		double dy=y-other.y;
		return sqrt(dx*dx+dy*dy);
	}
}


CoordXY[] init()
{
CoordXY[] result=new CoordXY[23];


result[0]=CoordXY(360758, 638456);
result[1]=CoordXY(360790, 638261);
result[2]=CoordXY(360788, 638260);
result[3]=CoordXY(360613, 638259);
result[4]=CoordXY(360563, 638258);
result[5]=CoordXY(360546, 638258);
result[6]=CoordXY(360509, 638258);
result[7]=CoordXY(360477, 638257);
result[8]=CoordXY(360476, 638257);
result[9]=CoordXY(360473, 638276);
result[10]=CoordXY(360471, 638288);
result[11]=CoordXY(360470, 638295);
result[12]=CoordXY(360469, 638306);
result[13]=CoordXY(360468, 638330);
result[14]=CoordXY(360593, 638361);
result[15]=CoordXY(360618, 638367);
result[16]=CoordXY(360652, 638380);
result[17]=CoordXY(360677, 638392);
result[18]=CoordXY(360720, 638414);
result[19]=CoordXY(360738, 638432);
result[20]=CoordXY(360745, 638448);
result[21]=CoordXY(360752, 638453);
result[22]=CoordXY(360758, 638456);

return result;
}

CoordXY[] init2()
{

CoordXY[] result=new CoordXY[4];

result[0]=CoordXY(360618, 638367);
result[1]=CoordXY(360629, 638371);
result[2]=CoordXY(360640, 638375);
result[3]=CoordXY(360652, 638380);

return result;
}

bool within(CoordXY a, CoordXY b, double maxDist)
{
	double dx=a.x-b.x;
	double dy=a.y-b.y;
	if ((dx*dx+dy*dy) < maxDist*maxDist)
		return true;
	return false;
}

const double searchDist=5;

double distFuncSegs(CoordXY[] pts, int previdx, int nextidx, CoordXY[] posib)
{
	foreach(CoordXY p; pts)
		writefln(p.x, " ", p.y);
	
	int ptsnumsegs=pts.length-1;

	int[double] splitsh;	

	int activeptssegs=0;
	
	double ptslength=0;
	for (int i=(previdx+1)%ptsnumsegs; i!=nextidx && (i!=0 || ptsnumsegs!=nextidx); i=(i+1)%ptsnumsegs) {
		ptslength+=pts[i].dist(pts[i+1]);
		activeptssegs++;
	}

	double[] ptsupto=new double[activeptssegs];
	
	splitsh[0]=1;
	double lensofar=0;
	int pos=0;
	for (int i=(previdx+1)%ptsnumsegs; i!=nextidx && (i!=0 || ptsnumsegs!=nextidx); i=(i+1)%ptsnumsegs) {
		lensofar+=pts[i].dist(pts[i+1]) / ptslength;
		if (lensofar>1)
			lensofar=1;

		ptsupto[pos++]=lensofar;
		splitsh[lensofar]=1;
	}
	
	double posiblength=0;
	for (int i=1; i<posib.length; i++) {
		posiblength+=posib[i-1].dist(posib[i]);
	}
	
	lensofar=0;
	double[] posibupto=new double[posib.length-1];
	pos=0;
	
	for (int i=1; i<posib.length; i++) {
		lensofar+=posib[i-1].dist(posib[i]) / posiblength;
		if (lensofar>1)
			lensofar=1;
		
		posibupto[pos++]=lensofar;
		splitsh[lensofar]=1;
	}
	
	double[] splits=new double[splitsh.length];
	pos=0;
	
	foreach (double d, int dummy; splitsh)
		splits[pos++]=d;

	splits.sort;	

	ptsupto[ptsupto.length-1]=1;
	posibupto[posibupto.length-1]=1;
	
	double lastptsupto=0;
	int ptsuptopos=0;
	double thisptsupto=ptsupto[0];
	
	double lastposibupto=0;
	int posibuptopos=0;
	double thisposibupto=posibupto[0];
	
	double result=0;
	
	for (int a=1; a<splits.length; a++) {
		double prevval=splits[a-1];
		double val=splits[a];
		
		double C=val-prevval;
		if (C<1E-10)
			continue;
		
		// to be on the safe side :)
		if (prevval>1) prevval=1;
		if (val>1) val=1;
		
		while (val>thisptsupto) {
			lastptsupto=thisptsupto;
			if (++ptsuptopos<ptsupto.length)
				thisptsupto=ptsupto[ptsuptopos];				
		}
		
		while (val>thisposibupto) {
			lastposibupto=thisposibupto;
			if (++posibuptopos<posibupto.length)
				thisposibupto=posibupto[posibuptopos];				
		}
		
		int ptsseg=(previdx+1+ptsuptopos) % ptsnumsegs;
		CoordXY ptsstart=pts[ptsseg];
		CoordXY ptsend=pts[ptsseg+1];
		
		CoordXY posibstart=posib[posibuptopos];
		CoordXY posibend=posib[posibuptopos+1];
		
		double ptsfac1=(prevval-lastptsupto)/(thisptsupto-lastptsupto);
		double ptsfac2=(val-lastptsupto)/(thisptsupto-lastptsupto);
		
		double posibfac1=(prevval-lastposibupto)/(thisposibupto-lastposibupto);
		double posibfac2=(val-lastposibupto)/(thisposibupto-lastposibupto);

		//writefln(ptsfac1, " ", ptsfac2, " ", posibfac1, " ", posibfac2);

		double diffx,diffy;
		
		diffx=ptsend.x-ptsstart.x;
		diffy=ptsend.y-ptsstart.y;
		
		double x10=ptsstart.x+diffx*ptsfac1;
		double y10=ptsstart.y+diffy*ptsfac1;
		double x11=ptsstart.x+diffx*ptsfac2;
		double y11=ptsstart.y+diffy*ptsfac2;

		//writefln("%f %f", diffx, diffy);

		diffx=posibend.x-posibstart.x;
		diffy=posibend.y-posibstart.y;
		
		double x20=posibstart.x+diffx*posibfac1;
		double y20=posibstart.y+diffy*posibfac1;
		double x21=posibstart.x+diffx*posibfac2;
		double y21=posibstart.y+diffy*posibfac2;
		
		if (!within(CoordXY(x10, y10), CoordXY(x20, y20), searchDist))
			return -1;

		writefln("%f %f %f %f %f %f %f %f", x10, y10, x11, y11, x20, y20, x21, y21);
		writefln("C: %f", C);
		
		writef("before: %f     ", result);
		double tmp=(x10*x10 + x11*x11 + x20*x20 + x10*(x11 - 2.0*x20 - x21) + x20*x21 + x21*x21 - x11*(x20 + 2.0*x21) + y10*y10 + y10*y11 + y11*y11 - 2.0*y10*y20 - y11*y20 + y20*y20 - y10*y21 - 2.0*y11*y21 + y20*y21 + y21*y21);
		writef("  (%f)  ", tmp);
		tmp*=C;
		tmp/=3.0;
		result+=tmp;
		writefln("after: %f   (tmp was %f)", result, tmp);
		writefln("");
	}
	
	writefln("result: ", result);
	
	return sqrt(result);
}

void main()
{
	CoordXY[] pts=init();
	CoordXY[] posib=init2();

	writefln("%0.10f", distFuncSegs(pts, 14, 16, posib));
}