double iterate211(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+r*dr;
		double
		uu = u+sign*2*y*z,
		vv = v+sign*2*z*x,
		ww = w-sign*2*x*y;
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate212(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+1.5*r*r*dr;
		double
		uu = u-sign/2.*x*(3*(y2-2*z2)+x2),
		vv = v-sign/2.*y*(3*(x2-2*z2)+y2),
		ww = w-sign/1.*z*(3*(x2+y2)-2*z2);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate213(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2*r*r*r*dr;
		double
		uu = u-sign*2*y*z*((y2-2*z2)+3*x2),
		vv = v-sign*2*z*x*((x2-2*z2)+3*y2),
		ww = w+sign*2*x*y*((x2+y2)-6*z2);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate214(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2.5*r*r*r*r*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u+sign/4.*x*(5*((y4+4*z4)-12*y2*z2)+10*x2*(y2-2*z2)+x4),
		vv = v+sign/4.*y*(5*((x4+4*z4)-12*x2*z2)+10*y2*(x2-2*z2)+y4),
		ww = w+sign/2.*z*(5*((x4+y4)+6*x2*y2)-20*z2*(x2+y2)+4*z4);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate215(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3*r*r*r*r*r*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u+sign/2.*y*z*(3*(y4+4*z4)-20*y2*z2+30*x2*(y2-2*z2)+15*x4),
		vv = v+sign/2.*z*x*(3*(x4+4*z4)-20*x2*z2+30*y2*(x2-2*z2)+15*y4),
		ww = w-sign/2.*x*y*(3*(x4+y4)+10*x2*y2-60*z2*(x2+y2)+60*z4);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate216(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r*r*r*r*r*r*dr;
		double
		x4 = x2*x2, x6 = x4*x2,
		y4 = y2*y2, y6 = y4*y2,
		z4 = z2*z2, z6 = z4*z2,
		uu = u-sign/8.*x*(7*((y6-8*z6)-30*(y4*z2-2*y2*z4))+35*x2*((y4+4*z4)-12*y2*z2)+21*x4*(y2-2*z2)+x6),
		vv = v-sign/8.*y*(7*((x6-8*z6)-30*(x4*z2-2*x2*z4))+35*y2*((x4+4*z4)-12*x2*z2)+21*y4*(x2-2*z2)+y6),
		ww = w-sign/4.*z*(7*((x6+y6)+15*(x4*y2+x2*y4))-70*z2*((x4+y4)+6*x2*y2)+84*z4*(x2+y2)-8*z6);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2);
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate321(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+1.5*r2*dr;
		double
		uu = u-sign*3*x*(y2-z2),
		vv = v-sign*3*y*(z2-x2),
		ww = w-sign*3*z*(x2-y2);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate322(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2.5*r2*r2*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u+sign*x*(2*x4-10*x2*(y2+z2)+5*(y4+z4)),
		vv = v+sign*y*(2*y4-10*y2*(z2+x2)+5*(z4+x4)),
		ww = w+sign*z*(2*z4-10*z2*(x2+y2)+5*(x4+y4));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate323(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2,
		y4 = y2*y2, y6 = y4*y2,
		z4 = z2*z2, z6 = z4*z2,
		uu = u-sign*x*(7*(y6-z6)-35*x2*(y4-z4)+21*x4*(y2-z2)),
		vv = v-sign*y*(7*(z6-x6)-35*y2*(z4-x4)+21*y4*(z2-x2)),
		ww = w-sign*z*(7*(x6-y6)-35*z2*(x4-y4)+21*z4*(x2-y2));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate324(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+4.5*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2,
		uu = u+sign*x*(9*(y8+z8)-84*x2*(y6+z6)+126*x4*(y4+z4)-36*x6*(y2+z2)+2*x8),
		vv = v+sign*y*(9*(z8+x8)-84*y2*(z6+x6)+126*y4*(z4+x4)-36*y6*(z2+x2)+2*y8),
		ww = w+sign*z*(9*(x8+y8)-84*z2*(x6+y6)+126*z4*(x4+y4)-36*z6*(x2+y2)+2*z8);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate325(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5.5*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2,
		uu = u-sign*x*(11*(y10-z10)-165*x2*(y8-z8)+462*x4*(y6-z6)-330*x6*(y4-z4)+55*x8*(y2-z2)),
		vv = v-sign*y*(11*(z10-x10)-165*y2*(z8-x8)+462*y4*(z6-x6)-330*y6*(z4-x4)+55*y8*(z2-x2)),
		ww = w-sign*z*(11*(x10-y10)-165*z2*(x8-y8)+462*z4*(x6-y6)-330*z6*(x4-y4)+55*z8*(x2-y2));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate326(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+6.5*r2*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2,
		uu = u+sign*x*(13*(y12+z12)-286*x2*(y10+z10)+1287*x4*(y8+z8)-1716*x6*(y6+z6)+715*x8*(y4+z4)-78*x10*(y2+z2)+2*x12),
		vv = v+sign*y*(13*(z12+x12)-286*y2*(z10+x10)+1287*y4*(z8+x8)-1716*y6*(z6+x6)+715*y8*(z4+x4)-78*y10*(z2+x2)+2*y12),
		ww = w+sign*z*(13*(x12+y12)-286*z2*(x10+y10)+1287*z4*(x8+y8)-1716*z6*(x6+y6)+715*z8*(x4+y4)-78*z10*(x2+y2)+2*z12);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate431(double u,double v,double w)
{
	double t = sqrt(2),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2*r3*dr;
		double
		uu = u+sign*32/9.*t*y*z*(y2-z2),
		vv = v+sign*32/9.*t*z*x*(z2-x2),
		ww = w+sign*32/9.*t*x*y*(x2-y2);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate432(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r3*r3*dr;
		double
		x4 = x2*x2,x6 = x4*x2,
		y4 = y2*y2,y6 = y4*y2,
		z4 = z2*z2,z6 = z4*z2,
		uu = u-sign*32/81.*x*(7*(2*(y6+z6)-15*(y4*z2+y2*z4))-35*x2*((y4+z4)-2*6*y2*z2)-21*x4*(y2+z2)+2*x6),
		vv = v-sign*32/81.*y*(7*(2*(z6+x6)-15*(z4*x2+z2*x4))-35*y2*((z4+x4)-2*6*z2*x2)-21*y4*(z2+x2)+2*y6),
		ww = w-sign*32/81.*z*(7*(2*(x6+y6)-15*(x4*y2+x2*y4))-35*z2*((x4+y4)-2*6*x2*y2)-21*z4*(x2+y2)+2*z6);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate433(double u,double v,double w)
{
	double t = sqrt(2),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2,
		uu = u-sign*640/243.*t*y*z*((y8-z8)-12*(y6*z2-y2*z6)+252*x2*(y4*z2-y2*z4)-126*x4*(y4-z4)+84*x6*(y2-z2)),
		vv = v-sign*640/243.*t*z*x*((z8-x8)-12*(z6*x2-z2*x6)+252*y2*(z4*x2-z2*x4)-126*y4*(z4-x4)+84*y6*(z2-x2)),
		ww = w-sign*640/243.*t*x*y*((x8-y8)-12*(x6*y2-x2*y6)+252*z2*(x4*y2-x2*y4)-126*z4*(x4-y4)+84*z6*(x2-y2));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate434(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+6.5*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2,
		uu = u-sign*256/2187.*x*(13*(-2*(y12+z12)+66*(y10*z2+y2*z10)+495*(y8*z4+y4*z8)-2*924*y6*z6)
					  +286*x2*((y10+z10)-2*45*(y8*z2+y2*z8)+210*(y6*z4+y4*z6))
					  +1287*x4*((y8+z8)+28*(y6*z2+y2*z6)-2*70*y4*z4)
					  +1716*x6*(-2*(y6+z6)+15*(y4*z2+y2*z4))
					  +715*x8*((y4+z4)-2*6*y2*z2)
					  +78*x10*(y2+z2)
					  -2*x12),
		vv = v-sign*256/2187.*y*(13*(-2*(z12+x12)+66*(z10*x2+z2*x10)+495*(z8*x4+z4*x8)-2*924*z6*x6)
					  +286*y2*((z10+x10)-2*45*(z8*x2+z2*x8)+210*(z6*x4+z4*x6))
					  +1287*y4*((z8+x8)+28*(z6*x2+z2*x6)-2*70*z4*x4)
					  +1716*y6*(-2*(z6+x6)+15*(z4*x2+z2*x4))
					  +715*y8*((z4+x4)-2*6*z2*x2)
					  +78*y10*(z2+x2)
					  -2*y12),
		ww = w-sign*256/2187.*z*(13*(-2*(x12+y12)+66*(x10*y2+x2*y10)+495*(x8*y4+x4*y8)-2*924*x6*y6)
					  +286*z2*((x10+y10)-2*45*(x8*y2+x2*y8)+210*(x6*y4+x4*y6))
					  +1287*z4*((x8+y8)+28*(x6*y2+x2*y6)-2*70*x4*y4)
					  +1716*z6*(-2*(x6+y6)+15*(x4*y2+x2*y4))
					  +715*z8*((x4+y4)-2*6*x2*y2)
					  +78*z10*(x2+y2)
					  -2*z12);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate435(double u,double v,double w)
{
	double t = sqrt(2),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+8*r3*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2,
		uu = u+sign*8192/6561.*t*y*z*((y14-z14)-35*(y12*z2-y2*z12)+715*(y8*z6-y6*z8)
						+105*x2*(26*(y10*z2-y2*z10)-143*(y8*z4-y4*z8))
						-1365*x4*((y10-z10)-66*(y6*z4-y4*z6))
						+5005*x6*((y8-z8)-12*(y6*z2-y2*z6))
						+6435*x8*(7*(y4*z2-y2*z4))
						-3003*x10*(y4-z4)
						+455*x12*(y2-z2)),
		vv = v+sign*8192/6561.*t*z*x*((z14-x14)-35*(z12*x2-z2*x12)+715*(z8*x6-z6*x8)
						+105*y2*(26*(z10*x2-z2*x10)-143*(z8*x4-z4*x8))
						-1365*y4*((z10-x10)-66*(z6*x4-z4*x6))
						+5005*y6*((z8-x8)-12*(z6*x2-z2*x6))
						+6435*y8*(7*(z4*x2-z2*x4))
						-3003*y10*(z4-x4)
						+455*y12*(z2-x2)),
		ww = w+sign*8192/6561.*t*x*y*((x14-y14)-35*(x12*y2-x2*y12)+715*(x8*y6-x6*y8)
						+105*z2*(26*(x10*y2-x2*y10)-143*(x8*y4-x4*y8))
						-1365*z4*((x10-y10)-66*(x6*y4-x4*y6))
						+5005*z6*((x8-y8)-12*(x6*y2-x2*y6))
						+6435*z8*(7*(x4*y2-x2*y4))
						-3003*z10*(x4-y4)
						+455*z12*(x2-y2));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate436(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+9.5*r3*r3*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2, x16 = x14*x2, x18 = x16*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2, y16 = y14*y2, y18 = y16*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2, z16 = z14*z2, z18 = z16*z2,
		uu = u+sign*2048/59049.*x*(19*(-2*(y18+z18)+153*(y16*z2+y2*z16)+3060*(y14*z4+y4*z14)-2*18564*(y12*z6+y6*z12)+43758*(y10*z8+y8*z10))
					  +969*x2*((y16+z16)-2*120*(y14*z2+y2*z14)+1820*(y12*z4+y4*z12)+8008*(y10*z6+y6*z10)-2*12870*y8*z8)
					  +11628*x4*((y14+z14)+91*(y12*z2+y2*z12)-2*1001*(y10*z4+y4*z10)+3003*(y8*z6+y6*z8))
					  +50388*x6*(-2*(y12+z12)+66*(y10*z2+y2*z10)+495*(y8*z4+y4*z8)-2*924*y6*z6)
					  +92378*x8*((y10+z10)-2*45*(y8*z2+y2*z8)+210*(y6*z4+y4*z6))
					  +75582*x10*((y8+z8)+28*(y6*z2+y2*z6)-2*70*y4*z4)
					  +27132*x12*(-2*(y6+z6)+15*(y4*z2+y2*z4))
					  +3876*x14*((y4+z4)-2*6*y2*z2)
					  +171*x16*(y2+z2)
					  -2*x18),
		vv = v+sign*2048/59049.*y*(19*(-2*(z18+x18)+153*(z16*x2+z2*x16)+3060*(z14*x4+z4*x14)-2*18564*(z12*x6+z6*x12)+43758*(z10*x8+z8*x10))
					  +969*y2*((z16+x16)-2*120*(z14*x2+z2*x14)+1820*(z12*x4+z4*x12)+8008*(z10*x6+z6*x10)-2*12870*z8*x8)
					  +11628*y4*((z14+x14)+91*(z12*x2+z2*x12)-2*1001*(z10*x4+z4*x10)+3003*(z8*x6+z6*x8))
					  +50388*y6*(-2*(z12+x12)+66*(z10*x2+z2*x10)+495*(z8*x4+z4*x8)-2*924*z6*x6)
					  +92378*y8*((z10+x10)-2*45*(z8*x2+z2*x8)+210*(z6*x4+z4*x6))
					  +75582*y10*((z8+x8)+28*(z6*x2+z2*x6)-2*70*z4*x4)
					  +27132*y12*(-2*(z6+x6)+15*(z4*x2+z2*x4))
					  +3876*y14*((z4+x4)-2*6*z2*x2)
					  +171*y16*(z2+x2)
					  -2*y18),
		ww = w+sign*2048/59049.*z*(19*(-2*(x18+y18)+153*(x16*y2+x2*y16)+3060*(x14*y4+x4*y14)-2*18564*(x12*y6+x6*y12)+43758*(x10*y8+x8*y10))
					  +969*z2*((x16+y16)-2*120*(x14*y2+x2*y14)+1820*(x12*y4+x4*y12)+8008*(x10*y6+x6*y10)-2*12870*x8*y8)
					  +11628*z4*((x14+y14)+91*(x12*y2+x2*y12)-2*1001*(x10*y4+x4*y10)+3003*(x8*y6+x6*y8))
					  +50388*z6*(-2*(x12+y12)+66*(x10*y2+x2*y10)+495*(x8*y4+x4*y8)-2*924*x6*y6)
					  +92378*z8*((x10+y10)-2*45*(x8*y2+x2*y8)+210*(x6*y4+x4*y6))
					  +75582*z10*((x8+y8)+28*(x6*y2+x2*y6)-2*70*x4*y4)
					  +27132*z12*(-2*(x6+y6)+15*(x4*y2+x2*y4))
					  +3876*z14*((x4+y4)-2*6*x2*y2)
					  +171*z16*(x2+y2)
					  -2*z18);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate621(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+1.5*r2*dr;
		double
		uu = u+sign/2.*x*(2*x2-3*(y2+z2)),
		vv = v+sign/2.*y*(2*y2-3*(z2+x2)),
		ww = w+sign/2.*z*(2*z2-3*(x2+y2));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate622(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2.5*r2*r2*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u+sign*5/4.*x*(2*x4-10*x2*(y2+z2)+7*(y4+z4)-12*y2*z2),
		vv = v+sign*5/4.*y*(2*y4-10*y2*(z2+x2)+7*(z4+x4)-12*z2*x2),
		ww = w+sign*5/4.*z*(2*z4-10*z2*(x2+y2)+7*(x4+y4)-12*x2*y2);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate623(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2,
		y4 = y2*y2, y6 = y4*y2,
		z4 = z2*z2, z6 = z4*z2,
		uu = u+sign*7/8.*x*(2*x6-21*x4*(y2+z2)-5*x2*((y4+z4)-48*y2*z2)+5*((y6+z6)-12*(y4*z2+y2*z4))),
		vv = v+sign*7/8.*y*(2*y6-21*y4*(z2+x2)-5*y2*((z4+x4)-48*z2*x2)+5*((z6+x6)-12*(z4*x2+z2*x4))),
		ww = w+sign*7/8.*z*(2*z6-21*z4*(x2+y2)-5*z2*((x4+y4)-48*x2*y2)+5*((x6+y6)-12*(x4*y2+x2*y4)));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate624(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+4.5*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2,
		uu = u+sign/16.*x*(34*x8-612*x6*(y2+z2)+126*x4*(13*(y4+z4)+24*y2*z2)-84*x2*(11*(y6+z6)+30*(y4*z2+y2*z4))+9*(19*(y8+z8)-224*(y6*z2+y2*z6)+700*y4*z4)),
		vv = v+sign/16.*y*(34*y8-612*y6*(z2+x2)+126*y4*(13*(z4+x4)+24*z2*x2)-84*y2*(11*(z6+x6)+30*(z4*x2+z2*x4))+9*(19*(z8+x8)-224*(z6*x2+z2*x6)+700*z4*x4)),
		ww = w+sign/16.*z*(34*z8-612*z6*(x2+y2)+126*z4*(13*(x4+y4)+24*x2*y2)-84*z2*(11*(x6+y6)+30*(x4*y2+x2*y4))+9*(19*(x8+y8)-224*(x6*y2+x2*y6)+700*x4*y4));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate625(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5.5*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2,
		uu = u+sign/32.*x*(62*x10-1705*x8*(y2+z2)+330*x6*(11*(y4+z4)+120*y2*z2)+462*x4*((y6+z6)+150*(y4*z2+y2*z4))
					-165*x2*(13*(y8+z8)-392*(y6*z2+y2*z6)+280*y4*z4)+11*(29*(y10+z10)-720*(y8*z2+y2*z8)+420*(y6*z4+y4*z6))),
		vv = v+sign/32.*y*(62*y10-1705*y8*(z2+x2)+330*y6*(11*(z4+x4)+120*z2*x2)+462*y4*((z6+x6)+150*(z4*x2+z2*x4))
					-165*y2*(13*(z8+x8)-392*(z6*x2+z2*x6)+280*z4*x4)+11*(29*(z10+x10)-720*(z8*x2+z2*x8)+420*(z6*x4+z4*x6))),
		ww = w+sign/32.*z*(62*z10-1705*z8*(x2+y2)+330*z6*(11*(x4+y4)+120*x2*y2)+462*z4*((x6+y6)+150*(x4*y2+x2*y4))
					-165*z2*(13*(x8+y8)-392*(x6*y2+x2*y6)+280*x4*y4)+11*(29*(x10+y10)-720*(x8*y2+x2*y8)+420*(x6*y4+x4*y6)));
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate626(double u,double v,double w)
{
	double
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+6.5*r2*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2,
		uu = u+sign*13/64.*x*(10*x12-390*x10*(y2+z2)+55*x8*(37*(y4+z4)+168*y2*z2)-132*x6*(23*(y6+z6)+210*(y4*z2+y2*z4))
					+99*x4*(25*(y8+z8)-56*(y6*z2+y2*z6)+1120*y4*z4)-110*x2*(7*(y10+z10)-90*(y8*z2+y2*z8)+336*(y6*z4+y4*z6))
					+67*(y12+z12)-2112*(y10*z2+y2*z10)+10890*(y8*z4+y4*z8)-12936*y6*z6),
		vv = v+sign*13/64.*y*(10*y12-390*y10*(z2+x2)+55*y8*(37*(z4+x4)+168*z2*x2)-132*y6*(23*(z6+x6)+210*(z4*x2+z2*x4))
					+99*y4*(25*(z8+x8)-56*(z6*x2+z2*x6)+1120*z4*x4)-110*y2*(7*(z10+x10)-90*(z8*x2+z2*x8)+336*(z6*x4+z4*x6))
					+67*(z12+x12)-2112*(z10*x2+z2*x10)+10890*(z8*x4+z4*x8)-12936*z6*x6),
		ww = w+sign*13/64.*z*(10*z12-390*z10*(x2+y2)+55*z8*(37*(x4+y4)+168*x2*y2)-132*z6*(23*(x6+y6)+210*(x4*y2+x2*y4))
					+99*z4*(25*(x8+y8)-56*(x6*y2+x2*y6)+1120*x4*y4)-110*z2*(7*(x10+y10)-90*(x8*y2+x2*y8)+336*(x6*y4+x4*y6))
					+67*(x12+y12)-2112*(x10*y2+x2*y10)+10890*(x8*y4+x4*y8)-12936*x6*y6);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate651(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3*r5*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u+sign*12/5.*y*z*((t-1)*y4+(t+1)*z4-4*t*y2*z2+2*x2*((t+5)*y2+(t-5)*z2)-2*t*x4),
		vv = v+sign*12/5.*z*x*((t-1)*z4+(t+1)*x4-4*t*z2*x2+2*y2*((t+5)*z2+(t-5)*x2)-2*t*y4),
		ww = w+sign*12/5.*x*y*((t-1)*x4+(t+1)*y4-4*t*x2*y2+2*z2*((t+5)*x2+(t-5)*y2)-2*t*z4);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate652(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5.5*r5*r5*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2,
		uu = u+sign/125.*x*(11*((93-33*t)*y10+(93+33*t)*z10-(2250+360*t)*y8*z2-(2250-360*t)*y2*z8+(1050+1890*t)*y6*z4+(1050-1890*t)*y4*z6)
					  -165*x2*((43-41*t)*y8+(43+41*t)*z8-(1260-28*t)*y6*z2-(1260+28*t)*y2*z6+700*y4*z4)
					  -462*x4*((2+40*t)*y6+(2-40*t)*z6+(525-15*t)*y4*z2+(525+15*t)*y2*z4)
					  +330*x6*((37+39*t)*y4+(37-39*t)*z4+420*y2*z2)
					  -55*x8*((107+39*t)*y2+(107-39*t)*z2)
					  +214*x10),
		vv = v+sign/125.*y*(11*((93-33*t)*z10+(93+33*t)*x10-(2250+360*t)*z8*x2-(2250-360*t)*z2*x8+(1050+1890*t)*z6*x4+(1050-1890*t)*z4*x6)
					  -165*y2*((43-41*t)*z8+(43+41*t)*x8-(1260-28*t)*z6*x2-(1260+28*t)*z2*x6+700*z4*x4)
					  -462*y4*((2+40*t)*z6+(2-40*t)*x6+(525-15*t)*z4*x2+(525+15*t)*z2*x4)
					  +330*y6*((37+39*t)*z4+(37-39*t)*x4+420*z2*x2)
					  -55*y8*((107+39*t)*z2+(107-39*t)*x2)
					  +214*y10),
		ww = w+sign/125.*z*(11*((93-33*t)*x10+(93+33*t)*y10-(2250+360*t)*x8*y2-(2250-360*t)*x2*y8+(1050+1890*t)*x6*y4+(1050-1890*t)*x4*y6)
					  -165*z2*((43-41*t)*x8+(43+41*t)*y8-(1260-28*t)*x6*y2-(1260+28*t)*x2*y6+700*x4*y4)
					  -462*z4*((2+40*t)*x6+(2-40*t)*y6+(525-15*t)*x4*y2+(525+15*t)*x2*y4)
					  +330*z6*((37+39*t)*x4+(37-39*t)*y4+420*x2*y2)
					  -55*z8*((107+39*t)*x2+(107-39*t)*y2)
					  +214*z10);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate653(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+8*r5*r5*r5*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2,
		uu = u+sign*32/625.*y*z*((125*t+29)*y14+(125*t-29)*z14-35*(51*t+77)*y12*z2-35*(51*t-77)*y2*z12+546*(13*t+46)*y10*z4+546*(13*t-46)*y4*z10-715*(7*t+87)*y8*z6-715*(7*t-87)*y6*z8
						-105*x2*((74*t-48)*y12+(74*t+48)*z12-130*(5*t-3)*y10*z2-130*(5*t+3)*y2*z10+143*(19*t+5)*y8*z4+143*(19*t-5)*y4*z8-3432*t*y6*z6)
						+455*x4*(3*(49*t-33)*y10+3*(49*t+33)*z10-110*(3*t-10)*y8*z2-110*(3*t+10)*y2*z8+990*(t+1)*y6*z4+990*(t-1)*y4*z6)
						-5005*x6*((43*t-13)*y8+(43*t+13)*z8-12*(t-25)*y6*z2-12*(t+25)*y2*z6+252*t*y4*z4)
						+6435*x8*(6*(7*t+2)*y6+6*(7*t-2)*z6+7*(9*t+25)*y4*z2+7*(9*t-25)*y2*z4)
						-3003*x10*((51*t+37)*y4+(51*t-37)*z4+60*t*y2*z2)
						+455*x12*((69*t+37)*y2+(69*t-37)*z2)
						-2070*x14*t),
		vv = v+sign*32/625.*z*x*((125*t+29)*z14+(125*t-29)*x14-35*(51*t+77)*z12*x2-35*(51*t-77)*z2*x12+546*(13*t+46)*z10*x4+546*(13*t-46)*z4*x10-715*(7*t+87)*z8*x6-715*(7*t-87)*z6*x8
						-105*y2*((74*t-48)*z12+(74*t+48)*x12-130*(5*t-3)*z10*x2-130*(5*t+3)*z2*x10+143*(19*t+5)*z8*x4+143*(19*t-5)*z4*x8-3432*t*z6*x6)
						+455*y4*(3*(49*t-33)*z10+3*(49*t+33)*x10-110*(3*t-10)*z8*x2-110*(3*t+10)*z2*x8+990*(t+1)*z6*x4+990*(t-1)*z4*x6)
						-5005*y6*((43*t-13)*z8+(43*t+13)*x8-12*(t-25)*z6*x2-12*(t+25)*z2*x6+252*t*z4*x4)
						+6435*y8*(6*(7*t+2)*z6+6*(7*t-2)*x6+7*(9*t+25)*z4*x2+7*(9*t-25)*z2*x4)
						-3003*y10*((51*t+37)*z4+(51*t-37)*x4+60*t*z2*x2)
						+455*y12*((69*t+37)*z2+(69*t-37)*x2)
						-2070*y14*t),
		ww = w+sign*32/625.*x*y*((125*t+29)*x14+(125*t-29)*y14-35*(51*t+77)*x12*y2-35*(51*t-77)*x2*y12+546*(13*t+46)*x10*y4+546*(13*t-46)*x4*y10-715*(7*t+87)*x8*y6-715*(7*t-87)*x6*y8
						-105*z2*((74*t-48)*x12+(74*t+48)*y12-130*(5*t-3)*x10*y2-130*(5*t+3)*x2*y10+143*(19*t+5)*x8*y4+143*(19*t-5)*x4*y8-3432*t*x6*y6)
						+455*z4*(3*(49*t-33)*x10+3*(49*t+33)*y10-110*(3*t-10)*x8*y2-110*(3*t+10)*x2*y8+990*(t+1)*x6*y4+990*(t-1)*x4*y6)
						-5005*z6*((43*t-13)*x8+(43*t+13)*y8-12*(t-25)*x6*y2-12*(t+25)*x2*y6+252*t*x4*y4)
						+6435*z8*(6*(7*t+2)*x6+6*(7*t-2)*y6+7*(9*t+25)*x4*y2+7*(9*t-25)*x2*y4)
						-3003*z10*((51*t+37)*x4+(51*t-37)*y4+60*t*x2*y2)
						+455*z12*((69*t+37)*x2+(69*t-37)*y2)
						-2070*z14*t);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate654(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+10.5*r5*r5*r5*r5*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2, x16 = x14*x2, x18 = x16*x2, x20 = x18*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2, y16 = y14*y2, y18 = y16*y2, y20 = y18*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2, z16 = z14*z2, z18 = z16*z2, z20 = z18*z2,
		uu = u+sign*2/15625.*x*(21*((8205-1463*t)*y20+(8205+1463*t)*z20-950*(625-21*t)*y18*z2-950*(625+21*t)*y2*z18+48450*(177+26*t)*y16*z4+48450*(177-26*t)*y4*z16
						   -193800*(229+41*t)*y14*z6-193800*(229-41*t)*y6*z14+629850*(189+23*t)*y12*z8+629850*(189-23*t)*y8*z12-160737720*y10*z10)
					  -1330*x2*(2*(2540-679*t)*y18+2*(2540+679*t)*z18-765*(271-73*t)*y16*z2-765*(271+73*t)*y2*z16+15300*(125+11*t)*y14*z4+15300*(125-11*t)*y4*z14
								-185640*(20+9*t)*y12*z6-185640*(20-9*t)*y6*z12+218790*(15+23*t)*y10*z8+218790*(15-23*t)*y8*z10)
					  +20349*x4*((3725-993*t)*y16+(3725+993*t)*z16-1200*(73-42*t)*y14*z2-1200*(73+42*t)*y2*z14+9100*(85-7*t)*y12*z4+9100*(85+7*t)*y4*z12
								 -200200*(5-t)*y10*z6-200200*(5+t)*y6*z10+1930500*y8*z8)
					  -116280*x6*((2995-573*t)*y14+(2995+573*t)*z14-455*(61-77*t)*y12*z2-455*(61+77*t)*y2*z12+10010*(30-t)*y10*z4+10010*(30+t)*y4*z10+75075*(1+t)*y8*z6+75075*(1-t)*y6*z8)
					  +293930*x8*(2*(1345-94*t)*y12+2*(1345+94*t)*z12-330*(1-75*t)*y10*z2-330*(1+75*t)*y2*z10+2475*(65+3*t)*y8*z4+2475*(65-3*t)*y4*z8+46200*y6*z6)
					  -352716*x10*((2685+187*t)*y10+(2685-187*t)*z10+450*(32+39*t)*y8*z2+450*(32-39*t)*y2*z8+3150*(25+t)*y6*z4+3150*(25-t)*y4*z6)
					  +203490*x12*((3005+577*t)*y8+(3005-577*t)*z8+140*(139+81*t)*y6*z2+140*(139-81*t)*y2*z6+52500*y4*z4)
					  -54264*x14*(2*(1850+491*t)*y6+2*(1850-491*t)*z6+75*(289+81*t)*y4*z2+75*(289-81*t)*y2*z4)
					  +5985*x16*((5145+1387*t)*y4+(5145-1387*t)*z4+17340*y2*z2)
					  -210*x18*((8035+1387*t)*y2+(8035-1387*t)*z2)
					  +16070*x20),
		vv = v+sign*2/15625.*y*(21*((8205-1463*t)*z20+(8205+1463*t)*x20-950*(625-21*t)*z18*x2-950*(625+21*t)*z2*x18+48450*(177+26*t)*z16*x4+48450*(177-26*t)*z4*x16
						   -193800*(229+41*t)*z14*x6-193800*(229-41*t)*z6*x14+629850*(189+23*t)*z12*x8+629850*(189-23*t)*z8*x12-160737720*z10*x10)
					  -1330*y2*(2*(2540-679*t)*z18+2*(2540+679*t)*x18-765*(271-73*t)*z16*x2-765*(271+73*t)*z2*x16+15300*(125+11*t)*z14*x4+15300*(125-11*t)*z4*x14
								-185640*(20+9*t)*z12*x6-185640*(20-9*t)*z6*x12+218790*(15+23*t)*z10*x8+218790*(15-23*t)*z8*x10)
					  +20349*y4*((3725-993*t)*z16+(3725+993*t)*x16-1200*(73-42*t)*z14*x2-1200*(73+42*t)*z2*x14+9100*(85-7*t)*z12*x4+9100*(85+7*t)*z4*x12
								 -200200*(5-t)*z10*x6-200200*(5+t)*z6*x10+1930500*z8*x8)
					  -116280*y6*((2995-573*t)*z14+(2995+573*t)*x14-455*(61-77*t)*z12*x2-455*(61+77*t)*z2*x12+10010*(30-t)*z10*x4+10010*(30+t)*z4*x10+75075*(1+t)*z8*x6+75075*(1-t)*z6*x8)
					  +293930*y8*(2*(1345-94*t)*z12+2*(1345+94*t)*x12-330*(1-75*t)*z10*x2-330*(1+75*t)*z2*x10+2475*(65+3*t)*z8*x4+2475*(65-3*t)*z4*x8+46200*z6*x6)
					  -352716*y10*((2685+187*t)*z10+(2685-187*t)*x10+450*(32+39*t)*z8*x2+450*(32-39*t)*z2*x8+3150*(25+t)*z6*x4+3150*(25-t)*z4*x6)
					  +203490*y12*((3005+577*t)*z8+(3005-577*t)*x8+140*(139+81*t)*z6*x2+140*(139-81*t)*z2*x6+52500*z4*x4)
					  -54264*y14*(2*(1850+491*t)*z6+2*(1850-491*t)*x6+75*(289+81*t)*z4*x2+75*(289-81*t)*z2*x4)
					  +5985*y16*((5145+1387*t)*z4+(5145-1387*t)*x4+17340*z2*x2)
					  -210*y18*((8035+1387*t)*z2+(8035-1387*t)*x2)
					  +16070*y20),
		ww = w+sign*2/15625.*z*(21*((8205-1463*t)*x20+(8205+1463*t)*y20-950*(625-21*t)*x18*y2-950*(625+21*t)*x2*y18+48450*(177+26*t)*x16*y4+48450*(177-26*t)*x4*y16
						   -193800*(229+41*t)*x14*y6-193800*(229-41*t)*x6*y14+629850*(189+23*t)*x12*y8+629850*(189-23*t)*x8*y12-160737720*x10*y10)
					  -1330*z2*(2*(2540-679*t)*x18+2*(2540+679*t)*y18-765*(271-73*t)*x16*y2-765*(271+73*t)*x2*y16+15300*(125+11*t)*x14*y4+15300*(125-11*t)*x4*y14
								-185640*(20+9*t)*x12*y6-185640*(20-9*t)*x6*y12+218790*(15+23*t)*x10*y8+218790*(15-23*t)*x8*y10)
					  +20349*z4*((3725-993*t)*x16+(3725+993*t)*y16-1200*(73-42*t)*x14*y2-1200*(73+42*t)*x2*y14+9100*(85-7*t)*x12*y4+9100*(85+7*t)*x4*y12
								 -200200*(5-t)*x10*y6-200200*(5+t)*x6*y10+1930500*x8*y8)
					  -116280*z6*((2995-573*t)*x14+(2995+573*t)*y14-455*(61-77*t)*x12*y2-455*(61+77*t)*x2*y12+10010*(30-t)*x10*y4+10010*(30+t)*x4*y10+75075*(1+t)*x8*y6+75075*(1-t)*x6*y8)
					  +293930*z8*(2*(1345-94*t)*x12+2*(1345+94*t)*y12-330*(1-75*t)*x10*y2-330*(1+75*t)*x2*y10+2475*(65+3*t)*x8*y4+2475*(65-3*t)*x4*y8+46200*x6*y6)
					  -352716*z10*((2685+187*t)*x10+(2685-187*t)*y10+450*(32+39*t)*x8*y2+450*(32-39*t)*x2*y8+3150*(25+t)*x6*y4+3150*(25-t)*x4*y6)
					  +203490*z12*((3005+577*t)*x8+(3005-577*t)*y8+140*(139+81*t)*x6*y2+140*(139-81*t)*x2*y6+52500*x4*y4)
					  -54264*z14*(2*(1850+491*t)*x6+2*(1850-491*t)*y6+75*(289+81*t)*x4*y2+75*(289-81*t)*x2*y4)
					  +5985*z16*((5145+1387*t)*x4+(5145-1387*t)*y4+17340*x2*y2)
					  -210*z18*((8035+1387*t)*x2+(8035-1387*t)*y2)
					  +16070*z20);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate655(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+13*r5*r5*r5*r5*r5*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2, x16 = x14*x2, x18 = x16*x2, x20 = x18*x2, x22 = x20*x2, x24 = x22*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2, y16 = y14*y2, y18 = y16*y2, y20 = y18*y2, y22 = y20*y2, y24 = y22*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2, z16 = z14*z2, z18 = z16*z2, z20 = z18*z2, z22 = z20*z2, z24 = z22*z2,
		uu = u+sign*26/15625.*y*z*(2*(3125*t-144)*y24+2*(3125*t+144)*z24-20*(16193*t+14905)*y22*z2-20*(16193*t-14905)*y2*z22
						+506*(9943*t+14145)*y20*z4+506*(9943*t-14145)*y4*z20-10120*(3559*t+5320)*y18*z6-10120*(3559*t-5320)*y6*z18
						+24035*(5543*t+6735)*y16*z8+24035*(5543*t-6735)*y8*z16-416024*(679*t+465)*y14*z10-416024*(679*t-465)*y10*z14+359860760*t*y12*z12
						-20*x2*(21*(2151*t-2335)*y22+21*(2151*t+2335)*z22-2530*(625*t+76)*y20*z2-2530*(625*t-76)*y2*z20+26565*(565*t+701)*y18*z4+26565*(565*t-701)*y4*z18
								-216315*(315*t+781)*y16*z6-216315*(315*t-781)*y6*z16+1634380*(79*t+348)*y14*z8+1634380*(79*t-348)*y8*z14
								-4680270*(17*t+217)*y12*z10-4680270*(17*t-217)*y10*z12)
						+230*x4*(11*(8807*t-17105)*y20+11*(8807*t+17105)*z20-3850*(685*t-549)*y18*z2-3850*(685*t+549)*y2*z18+658350*(25*t-8)*y16*z4+658350*(25*t+8)*y4*z16
								 -426360*(157*t+85)*y14*z6-426360*(157*t-85)*y6*z14+1243550*(107*t+45)*y12*z8+1243550*(107*t-45)*y8*z12-179885160*t*y10*z10)
						-35420*x6*(2*(2691*t-7180)*y18+2*(2691*t+7180)*z18-285*(435*t-469)*y16*z2-285*(435*t+469)*y2*z16+11628*(31*t-55)*y14*z4+11628*(31*t+55)*y4*z14
								   -193800*(5*t+4)*y12*z6-193800*(5*t-4)*y6*z12+209950*(t+9)*y10*z8+209950*(t-9)*y8*z10)
						+24035*x8*(27*(1069*t-4005)*y16+27*(1069*t+4005)*z16-77520*(9*t-8)*y14*z2-77520*(9*t+8)*y2*z14+21420*(43*t-205)*y12*z4+21420*(43*t+205)*y4*z12
								   -397800*(9*t-1)*y10*z6-397800*(9*t+1)*y6*z10+1215500*t*y8*z8)
						-653752*x10*((1497*t-10495)*y14+(1497*t+10495)*z14-175*(299*t-99)*y12*z2-175*(299*t+99)*y2*z12-2730*(t+100)*y10*z4-2730*(t-100)*y4*z10
									 -17875*(7*t-1)*y8*z6-17875*(7*t+1)*y6*z8)
						+1040060*x12*(2*(t-5000)*y12+2*(t+5000)*z12-130*(301*t+101)*y10*z2-130*(301*t-101)*y2*z10-715*(37*t+195)*y8*z4-715*(37*t-195)*y4*z8-85800*t*y6*z6)
						+297160*x14*((4509*t+31515)*y10+(4509*t-31515)*z10+550*(169*t+148)*y8*z2+550*(169*t-148)*y2*z8+990*(107*t+195)*y6*z4+990*(107*t-195)*y4*z6)
						-408595*x16*((3193*t+11985)*y8+(3193*t-11985)*z8+60*(445*t+491)*y6*z2+60*(445*t-491)*y2*z6+26964*t*y4*z4)
						+96140*x18*(2*(2709*t+7220)*y6+2*(2709*t-7220)*z6+35*(659*t+491)*y4*z2+35*(659*t-491)*y2*z4)
						-3542*x20*(3*(8713*t+16895)*y4+3*(8713*t-16895)*z4+65900*t*y2*z2)
						+460*x22*((15303*t+16895)*y2+(15303*t-16895)*z2)
						-153030*x24*t),
		vv = v+sign*26/15625.*z*x*(2*(3125*t-144)*z24+2*(3125*t+144)*x24-20*(16193*t+14905)*z22*x2-20*(16193*t-14905)*z2*x22
						+506*(9943*t+14145)*z20*x4+506*(9943*t-14145)*z4*x20-10120*(3559*t+5320)*z18*x6-10120*(3559*t-5320)*z6*x18
						+24035*(5543*t+6735)*z16*x8+24035*(5543*t-6735)*z8*x16-416024*(679*t+465)*z14*x10-416024*(679*t-465)*z10*x14+359860760*t*z12*x12
						-20*y2*(21*(2151*t-2335)*z22+21*(2151*t+2335)*x22-2530*(625*t+76)*z20*x2-2530*(625*t-76)*z2*x20+26565*(565*t+701)*z18*x4+26565*(565*t-701)*z4*x18
								-216315*(315*t+781)*z16*x6-216315*(315*t-781)*z6*x16+1634380*(79*t+348)*z14*x8+1634380*(79*t-348)*z8*x14
								-4680270*(17*t+217)*z12*x10-4680270*(17*t-217)*z10*x12)
						+230*y4*(11*(8807*t-17105)*z20+11*(8807*t+17105)*x20-3850*(685*t-549)*z18*x2-3850*(685*t+549)*z2*x18+658350*(25*t-8)*z16*x4+658350*(25*t+8)*z4*x16
								 -426360*(157*t+85)*z14*x6-426360*(157*t-85)*z6*x14+1243550*(107*t+45)*z12*x8+1243550*(107*t-45)*z8*x12-179885160*t*z10*x10)
						-35420*y6*(2*(2691*t-7180)*z18+2*(2691*t+7180)*x18-285*(435*t-469)*z16*x2-285*(435*t+469)*z2*x16+11628*(31*t-55)*z14*x4+11628*(31*t+55)*z4*x14
								   -193800*(5*t+4)*z12*x6-193800*(5*t-4)*z6*x12+209950*(t+9)*z10*x8+209950*(t-9)*z8*x10)
						+24035*y8*(27*(1069*t-4005)*z16+27*(1069*t+4005)*x16-77520*(9*t-8)*z14*x2-77520*(9*t+8)*z2*x14+21420*(43*t-205)*z12*x4+21420*(43*t+205)*z4*x12
								   -397800*(9*t-1)*z10*x6-397800*(9*t+1)*z6*x10+1215500*t*z8*x8)
						-653752*y10*((1497*t-10495)*z14+(1497*t+10495)*x14-175*(299*t-99)*z12*x2-175*(299*t+99)*z2*x12-2730*(t+100)*z10*x4-2730*(t-100)*z4*x10
									 -17875*(7*t-1)*z8*x6-17875*(7*t+1)*z6*x8)
						+1040060*y12*(2*(t-5000)*z12+2*(t+5000)*x12-130*(301*t+101)*z10*x2-130*(301*t-101)*z2*x10-715*(37*t+195)*z8*x4-715*(37*t-195)*z4*x8-85800*t*z6*x6)
						+297160*y14*((4509*t+31515)*z10+(4509*t-31515)*x10+550*(169*t+148)*z8*x2+550*(169*t-148)*z2*x8+990*(107*t+195)*z6*x4+990*(107*t-195)*z4*x6)
						-408595*y16*((3193*t+11985)*z8+(3193*t-11985)*x8+60*(445*t+491)*z6*x2+60*(445*t-491)*z2*x6+26964*t*z4*x4)
						+96140*y18*(2*(2709*t+7220)*z6+2*(2709*t-7220)*x6+35*(659*t+491)*z4*x2+35*(659*t-491)*z2*x4)
						-3542*y20*(3*(8713*t+16895)*z4+3*(8713*t-16895)*x4+65900*t*z2*x2)
						+460*y22*((15303*t+16895)*z2+(15303*t-16895)*x2)
						-153030*y24*t),
		ww = w+sign*26/15625.*x*y*(2*(3125*t-144)*x24+2*(3125*t+144)*y24-20*(16193*t+14905)*x22*y2-20*(16193*t-14905)*x2*y22
						+506*(9943*t+14145)*x20*y4+506*(9943*t-14145)*x4*y20-10120*(3559*t+5320)*x18*y6-10120*(3559*t-5320)*x6*y18
						+24035*(5543*t+6735)*x16*y8+24035*(5543*t-6735)*x8*y16-416024*(679*t+465)*x14*y10-416024*(679*t-465)*x10*y14+359860760*t*x12*y12
						-20*z2*(21*(2151*t-2335)*x22+21*(2151*t+2335)*y22-2530*(625*t+76)*x20*y2-2530*(625*t-76)*x2*y20+26565*(565*t+701)*x18*y4+26565*(565*t-701)*x4*y18
								-216315*(315*t+781)*x16*y6-216315*(315*t-781)*x6*y16+1634380*(79*t+348)*x14*y8+1634380*(79*t-348)*x8*y14
								-4680270*(17*t+217)*x12*y10-4680270*(17*t-217)*x10*y12)
						+230*z4*(11*(8807*t-17105)*x20+11*(8807*t+17105)*y20-3850*(685*t-549)*x18*y2-3850*(685*t+549)*x2*y18+658350*(25*t-8)*x16*y4+658350*(25*t+8)*x4*y16
								 -426360*(157*t+85)*x14*y6-426360*(157*t-85)*x6*y14+1243550*(107*t+45)*x12*y8+1243550*(107*t-45)*x8*y12-179885160*t*x10*y10)
						-35420*z6*(2*(2691*t-7180)*x18+2*(2691*t+7180)*y18-285*(435*t-469)*x16*y2-285*(435*t+469)*x2*y16+11628*(31*t-55)*x14*y4+11628*(31*t+55)*x4*y14
								   -193800*(5*t+4)*x12*y6-193800*(5*t-4)*x6*y12+209950*(t+9)*x10*y8+209950*(t-9)*x8*y10)
						+24035*z8*(27*(1069*t-4005)*x16+27*(1069*t+4005)*y16-77520*(9*t-8)*x14*y2-77520*(9*t+8)*x2*y14+21420*(43*t-205)*x12*y4+21420*(43*t+205)*x4*y12
								   -397800*(9*t-1)*x10*y6-397800*(9*t+1)*x6*y10+1215500*t*x8*y8)
						-653752*z10*((1497*t-10495)*x14+(1497*t+10495)*y14-175*(299*t-99)*x12*y2-175*(299*t+99)*x2*y12-2730*(t+100)*x10*y4-2730*(t-100)*x4*y10
									 -17875*(7*t-1)*x8*y6-17875*(7*t+1)*x6*y8)
						+1040060*z12*(2*(t-5000)*x12+2*(t+5000)*y12-130*(301*t+101)*x10*y2-130*(301*t-101)*x2*y10-715*(37*t+195)*x8*y4-715*(37*t-195)*x4*y8-85800*t*x6*y6)
						+297160*z14*((4509*t+31515)*x10+(4509*t-31515)*y10+550*(169*t+148)*x8*y2+550*(169*t-148)*x2*y8+990*(107*t+195)*x6*y4+990*(107*t-195)*x4*y6)
						-408595*z16*((3193*t+11985)*x8+(3193*t-11985)*y8+60*(445*t+491)*x6*y2+60*(445*t-491)*x2*y6+26964*t*x4*y4)
						+96140*z18*(2*(2709*t+7220)*x6+2*(2709*t-7220)*y6+35*(659*t+491)*x4*y2+35*(659*t-491)*x2*y4)
						-3542*z20*(3*(8713*t+16895)*x4+3*(8713*t-16895)*y4+65900*t*x2*y2)
						+460*z22*((15303*t+16895)*x2+(15303*t-16895)*y2)
						-153030*z24*t);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate656(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r5 = r*r*r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+15.5*r5*r5*r5*r5*r5*r5*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2, x16 = x14*x2, x18 = x16*x2, x20 = x18*x2, x22 = x20*x2, x24 = x22*x2, x26 = x24*x2, x28 = x26*x2, x30 = x28*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2, y16 = y14*y2, y18 = y16*y2, y20 = y18*y2, y22 = y20*y2, y24 = y22*y2, y26 = y24*y2, y28 = y26*y2, y30 = y28*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2, z16 = z14*z2, z18 = z16*z2, z20 = z18*z2, z22 = z20*z2, z24 = z22*z2, z26 = z24*z2, z28 = z26*z2, z30 = z28*z2,
		uu = u+sign*2/390625.*x*(31*(2*(96683-19778*t)*y30+2*(96683+19778*t)*z30-435*(78125+521*t)*y28*z2-435*(78125-521*t)*y2*z28+27405*(38035+8073*t)*y26*z4+27405*(38035-8073*t)*y4*z26
						   -1187550*(11205+4174*t)*y24*z6-1187550*(11205-4174*t)*y6*z24+5852925*(14055+6923*t)*y22*z8+5852925*(14055-6923*t)*y8*z22
						   -30045015*(8825+5643*t)*y20*z10-30045015*(8825-5643*t)*y10*z20+172986450*(2435+2374*t)*y18*z12+172986450*(2435-2374*t)*y12*z18
						   -145422675*(1565+4313*t)*y16*z14-145422675*(1565-4313*t)*y14*z16)
					  -4495*x2*((115241-40077*t)*y28+(115241+40077*t)*z28-756*(20045-3776*t)*y26*z2-756*(20045+3776*t)*y2*z26+511875*(625-11*t)*y24*z4+511875*(625+11*t)*y4*z24
								-5651100*(557+95*t)*y22*z6-5651100*(557-95*t)*y6*z22+31081050*(523+128*t)*y20*z8+31081050*(523-128*t)*y8*z20-65615550*(791+179*t)*y18*z10-65615550*(791-179*t)*y10*z18
								+152108775*(661+87*t)*y16*z12+152108775*(661-87*t)*y12*z16-125564958000.*y14*z14)
					  +169911*x4*((75151-32525*t)*y26+(75151+32525*t)*z26-325*(24465-7277*t)*y24*z2-325*(24465+7277*t)*y2*z24+149500*(727-170*t)*y22*z4+149500*(727+170*t)*y4*z22
								  -1151150*(625+29*t)*y20*z6-1151150*(625-29*t)*y6*z20+7811375*(255+77*t)*y18*z8+7811375*(255-77*t)*y8*z18-53117350*(65+46*t)*y16*z10-53117350*(65-46*t)*y10*z16
								  +48288500*(35+87*t)*y14*z12+48288500*(35-87*t)*y12*z14)
					  -2629575*x6*(2*(25343-12624*t)*y24+2*(25343+12624*t)*z24-276*(17195-5577*t)*y22*z2-276*(17195+5577*t)*y2*z22+53130*(829-369*t)*y20*z4+53130*(829+369*t)*y4*z20
								   -1345960*(185-24*t)*y18*z6-1345960*(185+24*t)*y6*z18+18386775*(25-3*t)*y16*z8+18386775*(25+3*t)*y8*z16-49031400*(19+t)*y14*z10-49031400*(19-t)*y10*z14+946454600*y12*z12)
					  +20160075*x8*((33491-19671*t)*y22+(33491+19671*t)*z22-1386*(2175-622*t)*y20*z2-1386*(2175+622*t)*y2*z20+109725*(153-107*t)*y18*z4+109725*(153+107*t)*y4*z18
									-373065*(245-33*t)*y16*z6-373065*(245+33*t)*y6*z16+15988500*(3-2*t)*y14*z8+15988500*(3+2*t)*y8*z14-16166150*(5+t)*y12*z10-16166150*(5-t)*y10*z12)
					  -84672315*x10*((20441-15939*t)*y20+(20441+15939*t)*z20-570*(3585-709*t)*y18*z2-570*(3585+709*t)*y2*z18+48450*(107-144*t)*y16*z4+48450*(107+144*t)*y4*z16
									 -193800*(215-13*t)*y14*z6-193800*(215+13*t)*y6*z14+3149250*(1-5*t)*y12*z8+3149250*(1+5*t)*y8*z12-46189000*y10*z10)
					  +206253075*x12*(2*(4843-6906*t)*y18+2*(4843+6906*t)*z18-153*(9685-687*t)*y16*z2-153*(9685+687*t)*y2*z16-15300*(1+275*t)*y14*z4-15300*(1-275*t)*y4*z14
									  -556920*(35+2*t)*y12*z6-556920*(35-2*t)*y6*z12-1093950*(9+5*t)*y10*z8-1093950*(9-5*t)*y8*z10)
					  -300540195*x14*((1-13125*t)*y16+(1+13125*t)*z16-240*(4845+344*t)*y14*z2-240*(4845-344*t)*y2*z14-9100*(211+287*t)*y12*z4-9100*(211-287*t)*y4*z12
									  -40040*(255+37*t)*y10*z6-40040*(255-37*t)*y6*z10-5791500*y8*z8)
					  -265182525*x16*((9689+13813*t)*y14+(9689-13813*t)*z14+91*(10745+2123*t)*y12*z2+91*(10745-2123*t)*y2*z12+10010*(233+162*t)*y10*z4+10010*(233-162*t)*y4*z10
									  +15015*(345+37*t)*y8*z6+15015*(345-37*t)*y6*z8)
					  +141120525*x18*(2*(10217+7968*t)*y12+2*(10217-7968*t)*z12+66*(13075+3743*t)*y10*z2+66*(13075-3743*t)*y2*z10+2475*(811+361*t)*y8*z4+2475*(811-361*t)*y4*z8+3187800*y6*z6)
					  -44352165*x20*((33509+19679*t)*y10+(33509-19679*t)*z10+90*(8565+2774*t)*y8*z2+90*(8565-2774*t)*y2*z8+19950*(79+19*t)*y6*z4+19950*(79-19*t)*y4*z6)
					  +7888725*x22*((50639+25227*t)*y8+(50639-25227*t)*z8+28*(24635+7353*t)*y6*z2+28*(24635-7353*t)*y2*z6+1050700*y4*z4)
					  -736281*x24*(2*(37637+16290*t)*y6+2*(37637-16290*t)*z6+135*(4405+817*t)*y4*z2+135*(4405-817*t)*y2*z4)
					  +31465*x26*((114919+39933*t)*y4+(114919-39933*t)*z4+475740*y2*z2)
					  -465*x28*((194209+39933*t)*y2+(194209-39933*t)*z2)
					  +388418*x30),
		vv = v+sign*2/390625.*y*(31*(2*(96683-19778*t)*z30+2*(96683+19778*t)*x30-435*(78125+521*t)*z28*x2-435*(78125-521*t)*z2*x28+27405*(38035+8073*t)*z26*x4+27405*(38035-8073*t)*z4*x26
						  -1187550*(11205+4174*t)*z24*x6-1187550*(11205-4174*t)*z6*x24+5852925*(14055+6923*t)*z22*x8+5852925*(14055-6923*t)*z8*x22
						  -30045015*(8825+5643*t)*z20*x10-30045015*(8825-5643*t)*z10*x20+172986450*(2435+2374*t)*z18*x12+172986450*(2435-2374*t)*z12*x18
						  -145422675*(1565+4313*t)*z16*x14-145422675*(1565-4313*t)*z14*x16)
					  -4495*y2*((115241-40077*t)*z28+(115241+40077*t)*x28-756*(20045-3776*t)*z26*x2-756*(20045+3776*t)*z2*x26+511875*(625-11*t)*z24*x4+511875*(625+11*t)*z4*x24
								-5651100*(557+95*t)*z22*x6-5651100*(557-95*t)*z6*x22+31081050*(523+128*t)*z20*x8+31081050*(523-128*t)*z8*x20-65615550*(791+179*t)*z18*x10-65615550*(791-179*t)*z10*x18
								+152108775*(661+87*t)*z16*x12+152108775*(661-87*t)*z12*x16-125564958000.*z14*x14)
					  +169911*y4*((75151-32525*t)*z26+(75151+32525*t)*x26-325*(24465-7277*t)*z24*x2-325*(24465+7277*t)*z2*x24+149500*(727-170*t)*z22*x4+149500*(727+170*t)*z4*x22
								  -1151150*(625+29*t)*z20*x6-1151150*(625-29*t)*z6*x20+7811375*(255+77*t)*z18*x8+7811375*(255-77*t)*z8*x18-53117350*(65+46*t)*z16*x10-53117350*(65-46*t)*z10*x16
								  +48288500*(35+87*t)*z14*x12+48288500*(35-87*t)*z12*x14)
					  -2629575*y6*(2*(25343-12624*t)*z24+2*(25343+12624*t)*x24-276*(17195-5577*t)*z22*x2-276*(17195+5577*t)*z2*x22+53130*(829-369*t)*z20*x4+53130*(829+369*t)*z4*x20
								   -1345960*(185-24*t)*z18*x6-1345960*(185+24*t)*z6*x18+18386775*(25-3*t)*z16*x8+18386775*(25+3*t)*z8*x16-49031400*(19+t)*z14*x10-49031400*(19-t)*z10*x14+946454600*z12*x12)
					  +20160075*y8*((33491-19671*t)*z22+(33491+19671*t)*x22-1386*(2175-622*t)*z20*x2-1386*(2175+622*t)*z2*x20+109725*(153-107*t)*z18*x4+109725*(153+107*t)*z4*x18
									-373065*(245-33*t)*z16*x6-373065*(245+33*t)*z6*x16+15988500*(3-2*t)*z14*x8+15988500*(3+2*t)*z8*x14-16166150*(5+t)*z12*x10-16166150*(5-t)*z10*x12)
					  -84672315*y10*((20441-15939*t)*z20+(20441+15939*t)*x20-570*(3585-709*t)*z18*x2-570*(3585+709*t)*z2*x18+48450*(107-144*t)*z16*x4+48450*(107+144*t)*z4*x16
									 -193800*(215-13*t)*z14*x6-193800*(215+13*t)*z6*x14+3149250*(1-5*t)*z12*x8+3149250*(1+5*t)*z8*x12-46189000*z10*x10)
					  +206253075*y12*(2*(4843-6906*t)*z18+2*(4843+6906*t)*x18-153*(9685-687*t)*z16*x2-153*(9685+687*t)*z2*x16-15300*(1+275*t)*z14*x4-15300*(1-275*t)*z4*x14
									  -556920*(35+2*t)*z12*x6-556920*(35-2*t)*z6*x12-1093950*(9+5*t)*z10*x8-1093950*(9-5*t)*z8*x10)
					  -300540195*y14*((1-13125*t)*z16+(1+13125*t)*x16-240*(4845+344*t)*z14*x2-240*(4845-344*t)*z2*x14-9100*(211+287*t)*z12*x4-9100*(211-287*t)*z4*x12
									  -40040*(255+37*t)*z10*x6-40040*(255-37*t)*z6*x10-5791500*z8*x8)
					  -265182525*y16*((9689+13813*t)*z14+(9689-13813*t)*x14+91*(10745+2123*t)*z12*x2+91*(10745-2123*t)*z2*x12+10010*(233+162*t)*z10*x4+10010*(233-162*t)*z4*x10
									  +15015*(345+37*t)*z8*x6+15015*(345-37*t)*z6*x8)
					  +141120525*y18*(2*(10217+7968*t)*z12+2*(10217-7968*t)*x12+66*(13075+3743*t)*z10*x2+66*(13075-3743*t)*z2*x10+2475*(811+361*t)*z8*x4+2475*(811-361*t)*z4*x8+3187800*z6*x6)
					  -44352165*y20*((33509+19679*t)*z10+(33509-19679*t)*x10+90*(8565+2774*t)*z8*x2+90*(8565-2774*t)*z2*x8+19950*(79+19*t)*z6*x4+19950*(79-19*t)*z4*x6)
					  +7888725*y22*((50639+25227*t)*z8+(50639-25227*t)*x8+28*(24635+7353*t)*z6*x2+28*(24635-7353*t)*z2*x6+1050700*z4*x4)
					  -736281*y24*(2*(37637+16290*t)*z6+2*(37637-16290*t)*x6+135*(4405+817*t)*z4*x2+135*(4405-817*t)*z2*x4)
					  +31465*y26*((114919+39933*t)*z4+(114919-39933*t)*x4+475740*z2*x2)
					  -465*y28*((194209+39933*t)*z2+(194209-39933*t)*x2)
					  +388418*y30),
		ww = w+sign*2/390625.*z*(31*(2*(96683-19778*t)*x30+2*(96683+19778*t)*y30-435*(78125+521*t)*x28*y2-435*(78125-521*t)*x2*y28+27405*(38035+8073*t)*x26*y4+27405*(38035-8073*t)*x4*y26
						  -1187550*(11205+4174*t)*x24*y6-1187550*(11205-4174*t)*x6*y24+5852925*(14055+6923*t)*x22*y8+5852925*(14055-6923*t)*x8*y22
						  -30045015*(8825+5643*t)*x20*y10-30045015*(8825-5643*t)*x10*y20+172986450*(2435+2374*t)*x18*y12+172986450*(2435-2374*t)*x12*y18
						  -145422675*(1565+4313*t)*x16*y14-145422675*(1565-4313*t)*x14*y16)
					  -4495*z2*((115241-40077*t)*x28+(115241+40077*t)*y28-756*(20045-3776*t)*x26*y2-756*(20045+3776*t)*x2*y26+511875*(625-11*t)*x24*y4+511875*(625+11*t)*x4*y24
								-5651100*(557+95*t)*x22*y6-5651100*(557-95*t)*x6*y22+31081050*(523+128*t)*x20*y8+31081050*(523-128*t)*x8*y20-65615550*(791+179*t)*x18*y10-65615550*(791-179*t)*x10*y18
								+152108775*(661+87*t)*x16*y12+152108775*(661-87*t)*x12*y16-125564958000.*x14*y14)
					  +169911*z4*((75151-32525*t)*x26+(75151+32525*t)*y26-325*(24465-7277*t)*x24*y2-325*(24465+7277*t)*x2*y24+149500*(727-170*t)*x22*y4+149500*(727+170*t)*x4*y22
								  -1151150*(625+29*t)*x20*y6-1151150*(625-29*t)*x6*y20+7811375*(255+77*t)*x18*y8+7811375*(255-77*t)*x8*y18-53117350*(65+46*t)*x16*y10-53117350*(65-46*t)*x10*y16
								  +48288500*(35+87*t)*x14*y12+48288500*(35-87*t)*x12*y14)
					  -2629575*z6*(2*(25343-12624*t)*x24+2*(25343+12624*t)*y24-276*(17195-5577*t)*x22*y2-276*(17195+5577*t)*x2*y22+53130*(829-369*t)*x20*y4+53130*(829+369*t)*x4*y20
								   -1345960*(185-24*t)*x18*y6-1345960*(185+24*t)*x6*y18+18386775*(25-3*t)*x16*y8+18386775*(25+3*t)*x8*y16-49031400*(19+t)*x14*y10-49031400*(19-t)*x10*y14+946454600*x12*y12)
					  +20160075*z8*((33491-19671*t)*x22+(33491+19671*t)*y22-1386*(2175-622*t)*x20*y2-1386*(2175+622*t)*x2*y20+109725*(153-107*t)*x18*y4+109725*(153+107*t)*x4*y18
									-373065*(245-33*t)*x16*y6-373065*(245+33*t)*x6*y16+15988500*(3-2*t)*x14*y8+15988500*(3+2*t)*x8*y14-16166150*(5+t)*x12*y10-16166150*(5-t)*x10*y12)
					  -84672315*z10*((20441-15939*t)*x20+(20441+15939*t)*y20-570*(3585-709*t)*x18*y2-570*(3585+709*t)*x2*y18+48450*(107-144*t)*x16*y4+48450*(107+144*t)*x4*y16
									 -193800*(215-13*t)*x14*y6-193800*(215+13*t)*x6*y14+3149250*(1-5*t)*x12*y8+3149250*(1+5*t)*x8*y12-46189000*x10*y10)
					  +206253075*z12*(2*(4843-6906*t)*x18+2*(4843+6906*t)*y18-153*(9685-687*t)*x16*y2-153*(9685+687*t)*x2*y16-15300*(1+275*t)*x14*y4-15300*(1-275*t)*x4*y14
									  -556920*(35+2*t)*x12*y6-556920*(35-2*t)*x6*y12-1093950*(9+5*t)*x10*y8-1093950*(9-5*t)*x8*y10)
					  -300540195*z14*((1-13125*t)*x16+(1+13125*t)*y16-240*(4845+344*t)*x14*y2-240*(4845-344*t)*x2*y14-9100*(211+287*t)*x12*y4-9100*(211-287*t)*x4*y12
									  -40040*(255+37*t)*x10*y6-40040*(255-37*t)*x6*y10-5791500*x8*y8)
					  -265182525*z16*((9689+13813*t)*x14+(9689-13813*t)*y14+91*(10745+2123*t)*x12*y2+91*(10745-2123*t)*x2*y12+10010*(233+162*t)*x10*y4+10010*(233-162*t)*x4*y10
									  +15015*(345+37*t)*x8*y6+15015*(345-37*t)*x6*y8)
					  +141120525*z18*(2*(10217+7968*t)*x12+2*(10217-7968*t)*y12+66*(13075+3743*t)*x10*y2+66*(13075-3743*t)*x2*y10+2475*(811+361*t)*x8*y4+2475*(811-361*t)*x4*y8+3187800*x6*y6)
					  -44352165*z20*((33509+19679*t)*x10+(33509-19679*t)*y10+90*(8565+2774*t)*x8*y2+90*(8565-2774*t)*x2*y8+19950*(79+19*t)*x6*y4+19950*(79-19*t)*x4*y6)
					  +7888725*z22*((50639+25227*t)*x8+(50639-25227*t)*y8+28*(24635+7353*t)*x6*y2+28*(24635-7353*t)*x2*y6+1050700*x4*y4)
					  -736281*z24*(2*(37637+16290*t)*x6+2*(37637-16290*t)*y6+135*(4405+817*t)*x4*y2+135*(4405-817*t)*x2*y4)
					  +31465*z26*((114919+39933*t)*x4+(114919-39933*t)*y4+475740*x2*y2)
					  -465*z28*((194209+39933*t)*x2+(194209-39933*t)*y2)
					  +388418*z30);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r5 = r*r*r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1032(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r3*r3*dr;
		double
		x4 = x2*x2,x6 = x4*x2,
		y4 = y2*y2,y6 = y4*y2,
		z4 = z2*z2,z6 = z4*z2,
		uu = u+sign*56/81.*x*(2*(4+3*t)*y6+2*(4-3*t)*z6-15*(5-3*t)*y4*z2-15*(5+3*t)*y2*z4
							  -15*x2*((1+3*t)*y4+(1-3*t)*z4-20*y2*z2)
							  -3*x4*((7-9*t)*y2+(7+9*t)*z2) 
							  +2*x6),
		vv = v+sign*56/81.*y*(2*(4+3*t)*z6+2*(4-3*t)*x6-15*(5-3*t)*z4*x2-15*(5+3*t)*z2*x4
							  -15*y2*((1+3*t)*z4+(1-3*t)*x4-20*z2*x2)
							  -3*y4*((7-9*t)*z2+(7+9*t)*x2) 
							  +2*y6),
		ww = w+sign*56/81.*z*(2*(4+3*t)*x6+2*(4-3*t)*y6-15*(5-3*t)*x4*y2-15*(5+3*t)*x2*y4
							  -15*z2*((1+3*t)*x4+(1-3*t)*y4-20*x2*y2)
							  -3*z4*((7-9*t)*x2+(7+9*t)*y2) 
							  +2*z6);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1033(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2,
		uu = u+sign*160/243.*y*z*((9+5*t)*y8+(9-5*t)*z8-24*(5+t)*y6*z2-24*(5-t)*y2*z6+252*y4*z4
								  +36*x2*((1-3*t)*y6+(1+3*t)*z6+14*t*y4*z2-14*t*y2*z4)
								  -126*x4*((1-t)*y4+(1+t)*z4)
								  +84*x6*((1-t)*y2+(1+t)*z2)
								  -18*x8),
		vv = v+sign*160/243.*z*x*((9+5*t)*z8+(9-5*t)*x8-24*(5+t)*z6*x2-24*(5-t)*z2*x6+252*z4*x4
								  +36*y2*((1-3*t)*z6+(1+3*t)*x6+14*t*z4*x2-14*t*z2*x4)
								  -126*y4*((1-t)*z4+(1+t)*x4)
								  +84*y6*((1-t)*z2+(1+t)*x2)
								  -18*y8),
		ww = w+sign*160/243.*x*y*((9+5*t)*x8+(9-5*t)*y8-24*(5+t)*x6*y2-24*(5-t)*x2*y6+252*x4*y4
								  +36*z2*((1-3*t)*x6+(1+3*t)*y6+14*t*x4*y2-14*t*x2*y4)
								  -126*z4*((1-t)*x4+(1+t)*y4)
								  +84*z6*((1-t)*x2+(1+t)*y2)
								  -18*z8);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1034(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+6.5*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2,
		uu = u+sign*104/2187.*x*(2*(203+22*t)*y12+2*(203-22*t)*z12-66*(59-9*t)*y10*z2-66*(59+9*t)*y2*z10+495*(55-27*t)*y8*z4+495*(55+27*t)*y4*z8-46200*y6*z6
								 -22*x2*((347+53*t)*y10+(347-53*t)*z10-90*(2+9*t)*y8*z2-90*(2-9*t)*y2*z8+210*(5-27*t)*y6*z4+210*(5+27*t)*y4*z6)
								 +693*x4*((49+5*t)*y8+(49-5*t)*z8+4*(1-45*t)*y6*z2+4*(1+45*t)*y2*z6+100*y4*z4)
								 -132*x6*(2*(172-5*t)*y6+2*(172+5*t)*z6+15*(11-45*t)*y4*z2+15*(11+45*t)*y2*z4)
								 +55*x8*(5*(71-11*t)*y4+5*(71+11*t)*z4+132*y2*z2)
								 -6*x10*((377-55*t)*y2+(377+55*t)*z2)
								 +58*x12),
		vv = v+sign*104/2187.*y*(2*(203+22*t)*z12+2*(203-22*t)*x12-66*(59-9*t)*z10*x2-66*(59+9*t)*z2*x10+495*(55-27*t)*z8*x4+495*(55+27*t)*z4*x8-46200*z6*x6
								 -22*y2*((347+53*t)*z10+(347-53*t)*x10-90*(2+9*t)*z8*x2-90*(2-9*t)*z2*x8+210*(5-27*t)*z6*x4+210*(5+27*t)*z4*x6)
								 +693*y4*((49+5*t)*z8+(49-5*t)*x8+4*(1-45*t)*z6*x2+4*(1+45*t)*z2*x6+100*z4*x4)
								 -132*y6*(2*(172-5*t)*z6+2*(172+5*t)*x6+15*(11-45*t)*z4*x2+15*(11+45*t)*z2*x4)
								 +55*y8*(5*(71-11*t)*z4+5*(71+11*t)*x4+132*z2*x2)
								 -6*y10*((377-55*t)*z2+(377+55*t)*x2)
								 +58*y12),
		ww = w+sign*104/2187.*z*(2*(203+22*t)*x12+2*(203-22*t)*y12-66*(59-9*t)*x10*y2-66*(59+9*t)*x2*y10+495*(55-27*t)*x8*y4+495*(55+27*t)*x4*y8-46200*x6*y6
								 -22*z2*((347+53*t)*x10+(347-53*t)*y10-90*(2+9*t)*x8*y2-90*(2-9*t)*x2*y8+210*(5-27*t)*x6*y4+210*(5+27*t)*x4*y6)
								 +693*z4*((49+5*t)*x8+(49-5*t)*y8+4*(1-45*t)*x6*y2+4*(1+45*t)*x2*y6+100*x4*y4)
								 -132*z6*(2*(172-5*t)*x6+2*(172+5*t)*y6+15*(11-45*t)*x4*y2+15*(11+45*t)*x2*y4)
								 +55*z8*(5*(71-11*t)*x4+5*(71+11*t)*y4+132*x2*y2)
								 -6*z10*((377-55*t)*x2+(377+55*t)*y2)
								 +58*z12);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1035(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+8*r3*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2,
		uu = u+sign*256/6561.*y*z*((285-29*t)*y14+(285+29*t)*z14-105*(19-17*t)*y12*z2-105*(19+17*t)*y2*z12+273*(15-77*t)*y10*z4+273*(15+77*t)*y4*z10+67210*t*y8*z6-67210*t*y6*z8
								   -105*x2*(2*(114+11*t)*y12+2*(114-11*t)*z12-52*(21+13*t)*y10*z2-52*(21-13*t)*y2*z10+143*(15+17*t)*y8*z4+143*(15-17*t)*y4*z8)
								   +1365*x4*(2*(93-2*t)*y10+2*(93+2*t)*z10-165*(3+t)*y8*z2-165*(3-t)*y2*z8+66*(15+17*t)*y6*z4+66*(15-17*t)*y4*z6)
								   -5005*x6*((159-13*t)*y8+(159+13*t)*z8-48*(3-2*t)*y6*z2-48*(3+2*t)*y2*z6+756*y4*z4)
								   +6435*x8*((147-5*t)*y6+(147+5*t)*z6+14*(9+4*t)*y4*z2+14*(9-4*t)*y2*z4)
								   -9009*x10*((55+t)*y4+(55-t)*z4+40*y2*z2)
								   +1365*x12*((67+t)*y2+(67-t)*z2)
								   -6030*x14),
		vv = v+sign*256/6561.*z*x*((285-29*t)*z14+(285+29*t)*x14-105*(19-17*t)*z12*x2-105*(19+17*t)*z2*x12+273*(15-77*t)*z10*x4+273*(15+77*t)*z4*x10+67210*t*z8*x6-67210*t*z6*x8
								   -105*y2*(2*(114+11*t)*z12+2*(114-11*t)*x12-52*(21+13*t)*z10*x2-52*(21-13*t)*z2*x10+143*(15+17*t)*z8*x4+143*(15-17*t)*z4*x8)
								   +1365*y4*(2*(93-2*t)*z10+2*(93+2*t)*x10-165*(3+t)*z8*x2-165*(3-t)*z2*x8+66*(15+17*t)*z6*x4+66*(15-17*t)*z4*x6)
								   -5005*y6*((159-13*t)*z8+(159+13*t)*x8-48*(3-2*t)*z6*x2-48*(3+2*t)*z2*x6+756*z4*x4)
								   +6435*y8*((147-5*t)*z6+(147+5*t)*x6+14*(9+4*t)*z4*x2+14*(9-4*t)*z2*x4)
								   -9009*y10*((55+t)*z4+(55-t)*x4+40*z2*x2)
								   +1365*y12*((67+t)*z2+(67-t)*x2)
								   -6030*y14),
		ww = w+sign*256/6561.*x*y*((285-29*t)*x14+(285+29*t)*y14-105*(19-17*t)*x12*y2-105*(19+17*t)*x2*y12+273*(15-77*t)*x10*y4+273*(15+77*t)*x4*y10+67210*t*x8*y6-67210*t*x6*y8
								   -105*z2*(2*(114+11*t)*x12+2*(114-11*t)*y12-52*(21+13*t)*x10*y2-52*(21-13*t)*x2*y10+143*(15+17*t)*x8*y4+143*(15-17*t)*x4*y8)
								   +1365*z4*(2*(93-2*t)*x10+2*(93+2*t)*y10-165*(3+t)*x8*y2-165*(3-t)*x2*y8+66*(15+17*t)*x6*y4+66*(15-17*t)*x4*y6)
								   -5005*z6*((159-13*t)*x8+(159+13*t)*y8-48*(3-2*t)*x6*y2-48*(3+2*t)*x2*y6+756*x4*y4)
								   +6435*z8*((147-5*t)*x6+(147+5*t)*y6+14*(9+4*t)*x4*y2+14*(9-4*t)*x2*y4)
								   -9009*z10*((55+t)*x4+(55-t)*y4+40*x2*y2)
								   +1365*z12*((67+t)*x2+(67-t)*y2)
								   -6030*z14);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1036(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r3 = r*r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+9.5*r3*r3*r3*r3*r3*r3*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2, x14 = x12*x2, x16 = x14*x2, x18 = x16*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2, y14 = y12*y2, y16 = y14*y2, y18 = y16*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2, z14 = z12*z2, z16 = z14*z2, z18 = z16*z2,
		uu = u+sign*8/19683.*x*(19*(2*(758+551*t)*y18+2*(758-551*t)*z18-51*(1445-411*t)*y16*z2-51*(1445+411*t)*y2*z16+1020*(607-543*t)*y14*z4+1020*(607+543*t)*y4*z14
									-12376*(310-231*t)*y12*z6-12376*(310+231*t)*y6*z12+14586*(265-327*t)*y10*z8+14586*(265+327*t)*y8*z10)
								-323*x2*((3103+3717*t)*y16+(3103-3717*t)*z16-240*(419+66*t)*y14*z2-240*(419-66*t)*y2*z14-1820*(13+81*t)*y12*z4-1820*(13-81*t)*y4*z12
									-40040*(71-27*t)*y10*z6-40040*(71+27*t)*y6*z10+6821100*y8*z8)
								+3876*x4*(15*(151+239*t)*y14+15*(151-239*t)*z14-91*(851+213*t)*y12*z2-91*(851-213*t)*y2*z12-2002*(184-27*t)*y10*z4-2002*(184+27*t)*y4*z10
									+15015*(35+27*t)*y8*z6+15015*(35-27*t)*y6*z8)
								-16796*x6*(2*(707+1686*t)*y12+2*(707-1686*t)*z12-3498*(23+3*t)*y10*z2-3498*(23-3*t)*y2*z10-495*(193-189*t)*y8*z4-495*(193+189*t)*y4*z8+323400*y6*z6)
								+92378*x8*((65+1071*t)*y10+(65-1071*t)*z10-30*(706-15*t)*y8*z2-30*(706+15*t)*y2*z8+70*(157+189*t)*y6*z4+70*(157-189*t)*y4*z6)
								+25194*x10*((1217-3243*t)*y8+(1217+3243*t)*z8+28*(1255-219*t)*y6*z2+28*(1255+219*t)*y2*z6-21980*y4*z4)
								-27132*x12*(2*(412-577*t)*y6+2*(412+577*t)*z6+5*(941-219*t)*y4*z2+5*(941+219*t)*y2*z4)
								+1292*x14*((3413-3681*t)*y4+(3413+3681*t)*z4+11292*y2*z2)
								-171*x16*((1765-1227*t)*y2+(1765+1227*t)*z2)
								+3530*x18),
		vv = v+sign*8/19683.*y*(19*(2*(758+551*t)*z18+2*(758-551*t)*x18-51*(1445-411*t)*z16*x2-51*(1445+411*t)*z2*x16+1020*(607-543*t)*z14*x4+1020*(607+543*t)*z4*x14
									-12376*(310-231*t)*z12*x6-12376*(310+231*t)*z6*x12+14586*(265-327*t)*z10*x8+14586*(265+327*t)*z8*x10)
								-323*y2*((3103+3717*t)*z16+(3103-3717*t)*x16-240*(419+66*t)*z14*x2-240*(419-66*t)*z2*x14-1820*(13+81*t)*z12*x4-1820*(13-81*t)*z4*x12
									-40040*(71-27*t)*z10*x6-40040*(71+27*t)*z6*x10+6821100*z8*x8)
								+3876*y4*(15*(151+239*t)*z14+15*(151-239*t)*x14-91*(851+213*t)*z12*x2-91*(851-213*t)*z2*x12-2002*(184-27*t)*z10*x4-2002*(184+27*t)*z4*x10
									+15015*(35+27*t)*z8*x6+15015*(35-27*t)*z6*x8)
								-16796*y6*(2*(707+1686*t)*z12+2*(707-1686*t)*x12-3498*(23+3*t)*z10*x2-3498*(23-3*t)*z2*x10-495*(193-189*t)*z8*x4-495*(193+189*t)*z4*x8+323400*z6*x6)
								+92378*y8*((65+1071*t)*z10+(65-1071*t)*x10-30*(706-15*t)*z8*x2-30*(706+15*t)*z2*x8+70*(157+189*t)*z6*x4+70*(157-189*t)*z4*x6)
								+25194*y10*((1217-3243*t)*z8+(1217+3243*t)*x8+28*(1255-219*t)*z6*x2+28*(1255+219*t)*z2*x6-21980*z4*x4)
								-27132*y12*(2*(412-577*t)*z6+2*(412+577*t)*x6+5*(941-219*t)*z4*x2+5*(941+219*t)*z2*x4)
								+1292*y14*((3413-3681*t)*z4+(3413+3681*t)*x4+11292*z2*x2)
								-171*y16*((1765-1227*t)*z2+(1765+1227*t)*x2)
								+3530*y18),
		ww = w+sign*8/19683.*z*(19*(2*(758+551*t)*x18+2*(758-551*t)*y18-51*(1445-411*t)*x16*y2-51*(1445+411*t)*x2*y16+1020*(607-543*t)*x14*y4+1020*(607+543*t)*x4*y14
									-12376*(310-231*t)*x12*y6-12376*(310+231*t)*x6*y12+14586*(265-327*t)*x10*y8+14586*(265+327*t)*x8*y10)
								-323*z2*((3103+3717*t)*x16+(3103-3717*t)*y16-240*(419+66*t)*x14*y2-240*(419-66*t)*x2*y14-1820*(13+81*t)*x12*y4-1820*(13-81*t)*x4*y12
									-40040*(71-27*t)*x10*y6-40040*(71+27*t)*x6*y10+6821100*x8*y8)
								+3876*z4*(15*(151+239*t)*x14+15*(151-239*t)*y14-91*(851+213*t)*x12*y2-91*(851-213*t)*x2*y12-2002*(184-27*t)*x10*y4-2002*(184+27*t)*x4*y10
									+15015*(35+27*t)*x8*y6+15015*(35-27*t)*x6*y8)
								-16796*z6*(2*(707+1686*t)*x12+2*(707-1686*t)*y12-3498*(23+3*t)*x10*y2-3498*(23-3*t)*x2*y10-495*(193-189*t)*x8*y4-495*(193+189*t)*x4*y8+323400*x6*y6)
								+92378*z8*((65+1071*t)*x10+(65-1071*t)*y10-30*(706-15*t)*x8*y2-30*(706+15*t)*x2*y8+70*(157+189*t)*x6*y4+70*(157-189*t)*x4*y6)
								+25194*z10*((1217-3243*t)*x8+(1217+3243*t)*y8+28*(1255-219*t)*x6*y2+28*(1255+219*t)*x2*y6-21980*x4*y4)
								-27132*z12*(2*(412-577*t)*x6+2*(412+577*t)*y6+5*(941-219*t)*x4*y2+5*(941+219*t)*x2*y4)
								+1292*z14*((3413-3681*t)*x4+(3413+3681*t)*y4+11292*x2*y2)
								-171*z16*((1765-1227*t)*x2+(1765+1227*t)*y2)
								+3530*z18);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r3 = r*r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1522(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+2.5*r2*r2*dr;
		double
		x4 = x2*x2,
		y4 = y2*y2,
		z4 = z2*z2,
		uu = u-sign*5/32.*x*((5+7*t)*y4+(5-7*t)*z4-60*y2*z2+2*x2*((5-7*t)*y2+(5+7*t)*z2)-2*x4),
		vv = v-sign*5/32.*y*((5+7*t)*z4+(5-7*t)*x4-60*z2*x2+2*y2*((5-7*t)*z2+(5+7*t)*x2)-2*y4),
		ww = w-sign*5/32.*z*((5+7*t)*x4+(5-7*t)*y4-60*x2*y2+2*z2*((5-7*t)*x2+(5+7*t)*y2)-2*z4);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1523(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+3.5*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2,
		y4 = y2*y2, y6 = y4*y2,
		z4 = z2*z2, z6 = z4*z2,
		uu = u-sign*7/16.*x*(2*(4*t+15)*y6+2*(4*t-15)*z6-75*(t-3)*y4*z2-75*(t+3)*y2*z4
						  -15*x2*((t+15)*y4+(t-15)*z4-20*t*y2*z2)-3*x4*((7*t-45)*y2+(7*t+45)*z2)+2*t*x6),
		vv = v-sign*7/16.*y*(2*(4*t+15)*z6+2*(4*t-15)*x6-75*(t-3)*z4*x2-75*(t+3)*z2*x4
						  -15*y2*((t+15)*z4+(t-15)*x4-20*t*z2*x2)-3*y4*((7*t-45)*z2+(7*t+45)*x2)+2*t*y6),
		ww = w-sign*7/16.*z*(2*(4*t+15)*x6+2*(4*t-15)*y6-75*(t-3)*x4*y2-75*(t+3)*x2*y4
						  -15*z2*((t+15)*x4+(t-15)*y4-20*t*x2*y2)-3*z4*((7*t-45)*x2+(7*t+45)*y2)+2*t*z6);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1524(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+4.5*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2,
		uu = u-sign/128.*x*(9*((25-11*t)*y8+(25+11*t)*z8-560*y6*z2-560*y2*z6+700*y4*z4)
						   +84*x2*(-(5-11*t)*y6-(5+11*t)*z6+150*y4*z2+150*y2*z4)
						   -126*x4*((5+11*t)*y4+(5-11*t)*z4+120*y2*z2)
						   +36*x6*((25+11*t)*y2+(25-11*t)*z2)
						   -50*x8),
		vv = v-sign/128.*y*(9*((25-11*t)*z8+(25+11*t)*x8-560*z6*x2-560*z2*x6+700*z4*x4)
						   +84*y2*(-(5-11*t)*z6-(5+11*t)*x6+150*z4*x2+150*z2*x4)
						   -126*y4*((5+11*t)*z4+(5-11*t)*x4+120*z2*x2)
						   +36*y6*((25+11*t)*z2+(25-11*t)*x2)
						   -50*y8),
		ww = w-sign/128.*z*(9*((25-11*t)*x8+(25+11*t)*y8-560*x6*y2-560*x2*y6+700*x4*y4)
						   +84*z2*(-(5-11*t)*x6-(5+11*t)*y6+150*x4*y2+150*x2*y4)
						   -126*z4*((5+11*t)*x4+(5-11*t)*y4+120*x2*y2)
						   +36*z6*((25+11*t)*x2+(25-11*t)*y2)
						   -50*z8);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1525(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+5.5*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2,
		uu = u+sign*33/2048.*x*(17*(27*t-35)*y10+17*(27*t+35)*z10-150*(61*t+48)*y8*z2-150*(61*t-48)*y2*z8+350*(13*t+69)*y6*z4+350*(13*t-69)*y4*z6
							 -5*x2*((767*t-2265)*y8+(767*t+2265)*z8-140*(109*t+27)*y6*z2-140*(109*t-27)*y2*z6+9100*t*y4*z4)
							 +42*x4*((74*t-800)*y6+(74*t+800)*z6-25*(83*t+27)*y4*z2-25*(83*t-27)*y2*z4)
							 +10*x6*((193*t+2535)*y4+(193*t-2535)*z4+4980*t*y2*z2)
							 -5*x8*((341*t+845)*y2+(341*t-845)*z2)
							 +62*t*x10),
		vv = v+sign*33/2048.*y*(17*(27*t-35)*z10+17*(27*t+35)*x10-150*(61*t+48)*z8*x2-150*(61*t-48)*z2*x8+350*(13*t+69)*z6*x4+350*(13*t-69)*z4*x6
							 -5*y2*((767*t-2265)*z8+(767*t+2265)*x8-140*(109*t+27)*z6*x2-140*(109*t-27)*z2*x6+9100*t*z4*x4)
							 +42*y4*((74*t-800)*z6+(74*t+800)*x6-25*(83*t+27)*z4*x2-25*(83*t-27)*z2*x4)
							 +10*y6*((193*t+2535)*z4+(193*t-2535)*x4+4980*t*z2*x2)
							 -5*y8*((341*t+845)*z2+(341*t-845)*x2)
							 +62*t*y10),
		ww = w+sign*33/2048.*z*(17*(27*t-35)*x10+17*(27*t+35)*y10-150*(61*t+48)*x8*y2-150*(61*t-48)*x2*y8+350*(13*t+69)*x6*y4+350*(13*t-69)*x4*y6
							 -5*z2*((767*t-2265)*x8+(767*t+2265)*y8-140*(109*t+27)*x6*y2-140*(109*t-27)*x2*y6+9100*t*x4*y4)
							 +42*z4*((74*t-800)*x6+(74*t+800)*y6-25*(83*t+27)*x4*y2-25*(83*t-27)*x2*y4)
							 +10*z6*((193*t+2535)*x4+(193*t-2535)*y4+4980*t*x2*y2)
							 -5*z8*((341*t+845)*x2+(341*t-845)*y2)
							 +62*t*z10);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate1526(double u,double v,double w)
{
	double t = sqrt(5),
	x = u, x2 = x*x,
	y = v, y2 = y*y,
	z = w, z2 = z*z,
	r = sqrt(x2+y2+z2),r2 = r*r,dr = 1;
	if(r < distMin) distMin = r;	
	for(int i = 0; (i != iterMax) && (r <= 2); i++)
	{
		dr = 1+6.5*r2*r2*r2*r2*r2*r2*dr;
		double
		x4 = x2*x2, x6 = x4*x2, x8 = x6*x2, x10 = x8*x2, x12 = x10*x2,
		y4 = y2*y2, y6 = y4*y2, y8 = y6*y2, y10 = y8*y2, y12 = y10*y2,
		z4 = z2*z2, z6 = z4*z2, z8 = z6*z2, z10 = z8*z2, z12 = z10*z2,
		uu = u+sign*65/1024.*x*(2*(203+22*t)*y12+2*(203-22*t)*z12-66*(59-9*t)*y10*z2-66*(59+9*t)*y2*z10+495*(55-27*t)*y8*z4+495*(55+27*t)*y4*z8-46200*y6*z6
								-22*x2*((347+53*t)*y10+(347-53*t)*z10-90*(2+9*t)*y8*z2-90*(2-9*t)*y2*z8+210*(5-27*t)*y6*z4+210*(5+27*t)*y4*z6)
								+693*x4*((49+5*t)*y8+(49-5*t)*z8+4*(1-45*t)*y6*z2+4*(1+45*t)*y2*z6+100*y4*z4)
								-132*x6*(2*(172-5*t)*y6+2*(172+5*t)*z6+15*(11-45*t)*y4*z2+15*(11+45*t)*y2*z4)
								+55*x8*(5*(71-11*t)*y4+5*(71+11*t)*z4+132*y2*z2)
								-6*x10*((377-55*t)*y2+(377+55*t)*z2)
								+58*x12),
		vv = v+sign*65/1024.*y*(2*(203+22*t)*z12+2*(203-22*t)*x12-66*(59-9*t)*z10*x2-66*(59+9*t)*z2*x10+495*(55-27*t)*z8*x4+495*(55+27*t)*z4*x8-46200*z6*x6
								-22*y2*((347+53*t)*z10+(347-53*t)*x10-90*(2+9*t)*z8*x2-90*(2-9*t)*z2*x8+210*(5-27*t)*z6*x4+210*(5+27*t)*z4*x6)
								+693*y4*((49+5*t)*z8+(49-5*t)*x8+4*(1-45*t)*z6*x2+4*(1+45*t)*z2*x6+100*z4*x4)
								-132*y6*(2*(172-5*t)*z6+2*(172+5*t)*x6+15*(11-45*t)*z4*x2+15*(11+45*t)*z2*x4)
								+55*y8*(5*(71-11*t)*z4+5*(71+11*t)*x4+132*z2*x2)
								-6*y10*((377-55*t)*z2+(377+55*t)*x2)
								+58*y12),
		ww = w+sign*65/1024.*z*(2*(203+22*t)*x12+2*(203-22*t)*y12-66*(59-9*t)*x10*y2-66*(59+9*t)*x2*y10+495*(55-27*t)*x8*y4+495*(55+27*t)*x4*y8-46200*x6*y6
								-22*z2*((347+53*t)*x10+(347-53*t)*y10-90*(2+9*t)*x8*y2-90*(2-9*t)*x2*y8+210*(5-27*t)*x6*y4+210*(5+27*t)*x4*y6)
								+693*z4*((49+5*t)*x8+(49-5*t)*y8+4*(1-45*t)*x6*y2+4*(1+45*t)*x2*y6+100*x4*y4)
								-132*z6*(2*(172-5*t)*x6+2*(172+5*t)*y6+15*(11-45*t)*x4*y2+15*(11+45*t)*x2*y4)
								+55*z8*(5*(71-11*t)*x4+5*(71+11*t)*y4+132*x2*y2)
								-6*z10*((377-55*t)*x2+(377+55*t)*y2)
								+58*z12);
		x = uu; x2 = x*x;
		y = vv; y2 = y*y;
		z = ww; z2 = z*z;
		r = sqrt(x2+y2+z2); r2 = r*r;
		if (r < distMin) distMin = r;
	}
	return log(r)*r/(2*dr);
}

double iterate(double u,double v,double w)
{
	if(type == 211) return iterate211(u,v,w);
	if(type == 212) return iterate212(u,v,w);
	if(type == 213) return iterate213(u,v,w);
	if(type == 214) return iterate214(u,v,w);
	if(type == 215) return iterate215(u,v,w);
	if(type == 216) return iterate216(u,v,w);

	if(type == 321) return iterate321(u,v,w);
	if(type == 322) return iterate322(u,v,w);
	if(type == 323) return iterate323(u,v,w);
	if(type == 324) return iterate324(u,v,w);
	if(type == 325) return iterate325(u,v,w);
	if(type == 326) return iterate326(u,v,w);

	if(type == 431) return iterate431(u,v,w);
	if(type == 432) return iterate432(u,v,w);
	if(type == 433) return iterate433(u,v,w);
	if(type == 434) return iterate434(u,v,w);
	if(type == 435) return iterate435(u,v,w);
	if(type == 436) return iterate436(u,v,w);
	
	if(type == 621) return iterate621(u,v,w);
	if(type == 622) return iterate622(u,v,w);
	if(type == 623) return iterate623(u,v,w);
	if(type == 624) return iterate624(u,v,w);
	if(type == 625) return iterate625(u,v,w);
	if(type == 626) return iterate626(u,v,w);
	
	if(type == 651) return iterate651(u,v,w);
	if(type == 652) return iterate652(u,v,w);
	if(type == 653) return iterate653(u,v,w);
	if(type == 654) return iterate654(u,v,w);
	if(type == 655) return iterate655(u,v,w);
	if(type == 656) return iterate656(u,v,w);
	
	if(type == 1032) return iterate1032(u,v,w);
	if(type == 1033) return iterate1033(u,v,w);
	if(type == 1034) return iterate1034(u,v,w);
	if(type == 1035) return iterate1035(u,v,w);
	if(type == 1036) return iterate1036(u,v,w);
	
	if(type == 1522) return iterate1522(u,v,w);
	if(type == 1523) return iterate1523(u,v,w);
	if(type == 1524) return iterate1524(u,v,w);
	if(type == 1525) return iterate1525(u,v,w);
	if(type == 1526) return iterate1526(u,v,w);

	return 0;
}

double max(double a,double b)
{
	return (a < b) ? b : a;
}

Point3 dotMP(Matrix3 m,Point3 p)
{
	return (Point3){m.ax*p.x+m.ay*p.y+m.az*p.z,m.bx*p.x+m.by*p.y+m.bz*p.z,m.cx*p.x+m.cy*p.y+m.cz*p.z};
}

BColor colorNormal(double u,double v,double w,double e)
{
	double
	dx = iterate(u+e,v,w)-iterate(u-e,v,w),
	dy = iterate(u,v+e,w)-iterate(u,v-e,w),
	dz = iterate(u,v,w+e)-iterate(u,v,w-e),
	r = max(max(fabs(dx),fabs(dy)),fabs(dz));
	return (BColor){(1-dx/r)/2,(1-dy/r)/2,(1+dz/r)/2};
}

BColor renderPixel(double u,double v)
{
	Point3
		orig = dotMP(rot,(Point3){u,v,2}),
		dir = dotMP(rot,(Point3){0,0,-1});
	distMin = windowZoom;
	double len = 0,eps = epsMin;
	for(int i = 0; (i < stepMax*epsDiv) && (len <= 4); i++)
	{
		double dist = iterate(orig.x,orig.y,orig.z)/epsDiv;
		orig.x += dir.x*dist;
		orig.y += dir.y*dist;
		orig.z += dir.z*dist;
		len += dist;
		if(dist < eps/epsDiv)
		{
			double ao = 4*distMin*distMin*i/(stepMax*epsDiv);
			BColor color = colorNormal(orig.x,orig.y,orig.z,eps/2);
			return (BColor){(1-ao)*color.red+ao/2,(1-ao)*color.green-ao/2,(1-ao)*color.blue-ao/2};
		}
		eps = max(epsMin,len/(2*resMax));
	}
	return _gray;
}

void main()
{
	scale = windowZoom/resMax;	
	for(int j = 0; j != 2*resMax; j++)
	{
		double v = (j-resMax)*scale+offset.y;
		for(int i = 0; i != 2*resMax; i++)
		{
			double u = (i-resMax)*scale+offset.x;
			pixel[i][j] = renderPixel(u,v);
		}
	}
}