Modelo fotfot(Resultado* result,Fotograma* fot1, Fotograma* fot2, u16int  n_force, float vmin){
	uint n;
	Hel2D trans;
	float vv,vvant;
	//float maxX[3],maxg[3];
	//float maxim;
	u8int esx;
	Modelo mod;
	PLIST plist=get_new_plist();

#define np2 fot2->puntos.n
	n=min(fot1->puntos.n,np2);
	aj_decl_alloc_add(Puntoxy_double,comun12,n<<1);
	aj_decl_alloc_add(uint,ind_com,n);
	aj_decl_alloc_add(uint,ind_com2,n);
	aj_decl_alloc_add(bint,bcom2,np2);
	zeroset(bcom2,np2*sizeof(bint));
	SetupModelo(mod);

	Puntoff pfv;
	pfv.f=0;
	n=0;
	{Puntoxy_double *ptr=comun12;
	Puntof *punpf1=fot1->puntos.ppio;
	for(uint i=0;i<fot1->puntos.n;i++,punpf1++){
		uint nom=punpf1->n;
		Vadd(mod.fpuntos,uint,nom);
		bint bk=0;
		Puntof *punpf2=fot2->puntos.ppio;
		for(uint j=0;j<np2;j++,punpf2++){
			if(punpf2->n==nom){
				bk=1;
				*ptr++=punpf1->p;
				*ptr++=punpf2->p;
				ind_com[n]=i;
				ind_com2[n]=j;
				bcom2[j]=1;
				n++;
				break;
		}	}
		if(!bk){
			pfv.n=nom;
			pfv.p=i;
			Vadd(mod.fpuntosf,Puntoff,pfv);
		}
	}}

	pfv.f=1;
	for(uint j=0;j<np2;j++){
		if(!bcom2[j]){
			uint nom=fot2->puntos.ppio[j].n;
			Vadd(mod.fpuntos,uint,nom);
			pfv.n=nom;
			pfv.p=j;
			Vadd(mod.fpuntosf,Puntoff,pfv);
		}
	}

	//comun12 es una copia, no hace falta restaurar al final
	if(fot1->focal!=1.0 || fot2->focal!=1.0){
		double aux=1/fot1->focal,
				 auxb=1/fot2->focal;
		vmin*=(float)aux;
		Durchlaufei(Puntoxy_double,comun12,n){
			ptr->x*=aux; ptr->y*=aux; ptr++;
			ptr->x*=auxb; ptr->y*=auxb; ptr++;
		}
	}
	trans=Hel2D_pp(comun12,n);
	double cosg, sing;
	cosg=cos(trans.g);
	sing=sin(trans.g);

	CentroProy c;
	c.b=1;
	c.fot=fot1;
	c.P.X=c.P.Y=c.P.Z=0;
	zeroset_double(c.M,9);
	c.M[0][0]=c.M[1][1]=c.M[2][2]=1;
	Vadd(mod.centros,CentroProy,c);

	c.fot=fot2;
	c.M[0][2]=c.M[1][2]=c.M[2][0]=c.M[2][1]=0;
	c.M[2][2]=1;
	c.P.X=trans.Tx;
	c.P.Y=trans.Ty;
	c.M[0][0]=c.M[1][1]=cos(trans.g);
	c.M[0][1]=-sin(trans.g);
	c.M[1][0]=-c.M[0][1];
	c.P.Z=0;
	if(trans.esc>1.032 || trans.esc<.968 || (trans.Tx<0.06 && trans.Ty<0.06)) c.P.Z=1/trans.esc-1;
	Vadd(mod.centros,CentroProy,c);
	//Clculo de coordenadas modelo aproximadas
	uint nmal=0;
	aj_decl_alloc_add(u8int,malo,n);	//0: bien, 1: Z=x, 2: Z=y
	zeroset(malo,n*sizeof(bint));
	{PuntoXYZ_double const a={0,0,0};
	PuntoXYZ_double b,d;
	d.Z=b.Z=-1.0;
	Puntoxy_double *ptr=comun12;
	for(uint i=0;i<n;i++){
		PuntoM PM;
		PM.bbb=7;
		PM.index=fot1->puntos.ppio[ind_com[i]].n;
		b.X=ptr->x;
		b.Y=ptr++->y;
		d.X=ptr->x*cosg+ptr->y*sing;
		d.Y=-ptr->x*sing+ptr->y*cosg;
		ptr++;
		PM.den=secrr3_ap_foto(a,b,c.P,d,&PM.P);
		Vadd(mod.puntos,PuntoM,PM);
		if(PM.den<TOL_ACEPTAR){
			nmal++;
			if(PM.den<TOL_FF && n_force!=-1){result->nret=2; myreturn mod;}
		}
	}}
	//if((n>=n_force && n-nmal<n_force) || (n<n_force && n-nmal<(n+1)>>2)){
	if(n-nmal<n_force){
		result->nret=2;
		myreturn mod;
	}

	nmal=0;
	{double faux,fauxb;
	faux=c.P.X*c.M[0][0]+c.P.Y*c.M[0][1];
	fauxb=c.P.X*c.M[1][0]+c.P.Y*c.M[1][1];
	PuntoM *punpm=mod.puntos.ppio;
	for(uint i=0;i<n;i++,punpm++){
		if(punpm->den>=TOL_COPL) continue;
		nmal++;
		double den=-1/punpm->P.Z;
		double x,y;
		x=punpm->P.X;
		y=punpm->P.Y;
		punpm->P.X=x*den;
		punpm->P.Y=y*den;
		den=-1/(punpm->P.Z-c.P.Z);
		if(fabs(faux)>fabs(fauxb)){
			malo[i]=1;
			punpm->P.Z=x*c.M[0][0]+y*c.M[0][1]-faux;
		}else{
			malo[i]=2;
			punpm->P.Z=x*c.M[1][0]+y*c.M[1][1]-fauxb;
		}
		punpm->P.Z*=den;
	}}
	//Fin de cosg, sing

#define COPL
#ifdef COPL
	#define _ncopl(x)
#else
	#define _ncopl(x) x
#endif

	PuntoXYZ_double CG;
	float fM[3][3];
	CG.X=CG.Y=0;
	CG.Z=-1.0;
	{Durchlaufei(Puntoxy_double,comun12,n){
		CG.X+=ptr->x;	CG.Y+=ptr->y;
		ptr+=2;
	}}
	CG.X/=n;
	CG.Y/=n;
	uint n2=n<<1;
	aj_decl_alloc_add(float,A,5*n2);
	float (*B)[6]; checked_malloc(B,float(*)[6],n2*6*sizeof(float),goto salida_outofmem);	add_to_delete(B);
	aj_decl_alloc_add(float,L,4*n);
	float fden;
#ifndef COPL
	float parciales[9];
#else
	float parciales[6];
#endif
	uint n3=3*n;
	float Nf[25];
	aj_decl_alloc_add(float,Nfp,5*n3);
	float (*Np)[9]; checked_malloc(Np,float(*)[9],n*9*sizeof(float),goto salida_outofmem);	add_to_delete(Np);
	aj_decl_alloc_add(float,Afp,5*n3);
	float AtLf[5];
	aj_decl_alloc_add(float,AtLp,n3);
	float DXf[5];
	aj_decl_alloc_add(float,DXp,n3);
	/*ofstream fmatL("MatrizL.txt");
	ofstream fmatDX("MatrizDX.txt");*/
	{double X,Y,Z;
	double *iM=c.M[0];
	X=*iM++*c.P.X;		X+=*iM++*c.P.Y;	X+=*iM++*c.P.Z;	X=fabs(X);
	Y=*iM++*c.P.X;		Y+=*iM++*c.P.Y;	Y+=*iM++*c.P.Z;	Y=fabs(Y);
	Z=*iM++*c.P.X;		Z+=*iM++*c.P.Y;	Z+=*iM*c.P.Z;		Z=fabs(Z);
	if(X>Y){
		if(X>Z) esx=0;	else esx=2;
	}else{
		if(Y>Z) esx=1;	else esx=2;
	}}
	{double X,Y;
	X=c.P.X-CG.X;
	Y=c.P.Y-CG.Y;
	c.P.X=c.M[0][0]*X+c.M[0][1]*Y;
	c.P.Y=c.M[1][0]*X+c.M[1][1]*Y;
	c.P.Z-=CG.Z;
	}
	if(nmal){
		zeroset_float(A,5*n2);
		zeroset_float(B[0],6*n2);
	#ifndef COPL
		float *pB=B[0];
		fordowni(n,pB+=6){
			pB[0]=1; pB[3]=1;
		}
	#endif
	}

	uint iter=0;
	//maxX[1]=maxX[2]=maxg[1]=maxg[2]=-1;
	for(;;iter++){
		float _fmod;
		PuntoXYZ_double Pg;
		PuntoXYZ_float fGM;
		for(uint j=0;j<9;j++) fM[0][j]=(float)c.M[0][j];
		if(nmal!=0){
			Pg=GiraPunto(CG,c.M);
			fGM.X=(float)Pg.X;	fGM.Y=(float)Pg.Y;	fGM.Z=(float)Pg.Z;
			Pg+=c.P;
			_fmod=1.F/sqrtf((float)Pg.mod()*2);
		}
		//Matrices A y L;
		{float *pA=A, *pB=B[0], *pBb=B[n],
				*pL=L, *pLb=L+(n+n);
		PuntoM *punpm=mod.puntos.ppio;
		Puntoxy_double *punp=comun12;
		u8int *pmalo=malo;
		fordowni(n,(punpm++,pmalo++)){
			Puntoxy_double p,q;
			if(!*pmalo){
				PuntoXYZ_double Q;
				double den;
				float fden;
				PuntoXYZ_float rf;
				Puntoxy_float qf;

				Q=punpm->P-CG;

				p.x=-punpm->P.X/punpm->P.Z;
				p.y=-punpm->P.Y/punpm->P.Z;
				den=c.M[2][0]*Q.X+c.M[2][1]*Q.Y+c.M[2][2]*Q.Z;		rf.Z=(float)den;
				den-=c.P.Z;
				den=-1.0/den;
				fden=(float)den;
				rf.Z*=fden;
				q.x=c.M[0][0]*Q.X+c.M[0][1]*Q.Y+c.M[0][2]*Q.Z;		rf.X=(float)q.x*fden;
				q.x-=c.P.X;
				q.x*=den;		qf.x=(float)q.x;
				q.y=c.M[1][0]*Q.X+c.M[1][1]*Q.Y+c.M[1][2]*Q.Z;		rf.Y=(float)q.y*fden;
				q.y-=c.P.Y;
				q.y*=den;		qf.y=(float)q.y;

				{float faux=-1.0F/(float)punpm->P.Z;
				*pB++=faux;	*pB++=0;
				*pB++=0;		*pB++=faux;	
				*pB++=(float)p.x*faux;	*pB++=(float)p.y*faux;}

				{float *ipA=pA;
				if(esx>0) *ipA=-fden;	else *ipA=0;			ipA+=n2;
				if(esx>1) *ipA=0;		else *ipA=-qf.x*fden;	ipA+=n2;

				*ipA=rf.Y*qf.x;		ipA+=n2;
				*ipA=rf.Z-rf.X*qf.x;	ipA+=n2;
				*ipA=-rf.Y;}
				pA++;

				pBb[0]=fM[0][0]+fM[2][0]*qf.x;		pBb[0]*=fden;
				pBb[2]=fM[0][1]+fM[2][1]*qf.x;		pBb[2]*=fden;
				pBb[4]=fM[0][2]+fM[2][2]*qf.x;		pBb[4]*=fden;
				pBb[1]=fM[1][0]+fM[2][0]*qf.y;		pBb[1]*=fden;
				pBb[3]=fM[1][1]+fM[2][1]*qf.y;		pBb[3]*=fden;
				pBb[5]=fM[1][2]+fM[2][2]*qf.y;		pBb[5]*=fden;
				pBb+=6;

				{float *ipA=pA;
				if(esx>0) *ipA=0;			else *ipA=-fden;		ipA+=n2;
				if(esx>1) *ipA=-fden;	else *ipA=-qf.y*fden;	ipA+=n2;

				*ipA=-rf.Z+rf.Y*qf.y;	ipA+=n2;
				*ipA=-rf.X*qf.y;			ipA+=n2;
				*ipA=rf.X;}
				pA++;

			#ifdef COPL
				*pL++=(float)(punp->x-p.x);
				*pL++=(float)(punp->y-p.y);	punp++;
				*pLb++=(float)(punp->x-q.x);
				*pLb++=(float)(punp->y-q.y);	punp++;
			#endif
			}else{//coplanaridad
				PuntoXYZ_double Q;
				PuntoXYZ_float rf;
				_ncopl(u8int malox;)

			#ifndef COPL
				p.x=punpm->P.X;
				p.y=punpm->P.Y;
			#else
				p.x=punp->x; p.y=punp->y;	punp++;
				q.x=punp->x; q.y=punp->y;	punp++;
				fden=_fmod;
			#endif

				{double x,y,z;
				x=c.M[0][0]*p.x+c.M[0][1]*p.y-c.M[0][2];		rf.X=(float)x;
				y=c.M[1][0]*p.x+c.M[1][1]*p.y-c.M[1][2];		rf.Y=(float)y;
				z=c.M[2][0]*p.x+c.M[2][1]*p.y-c.M[2][2];		rf.Z=(float)z;
				Q.X=Pg.Y*z-Pg.Z*y;		_ncopl(parciales[6]=(float)Q.X;)
				Q.Y=Pg.Z*x-Pg.X*z;			_ncopl(parciales[7]=(float)Q.Y;)
				Q.Z=Pg.X*y-Pg.Y*x;}

			#ifndef COPL
				if(*pmalo==1){q.x=punpm->P.Z;	q.y=(Q.Z-Q.X*q.x)/Q.Y;}
				else{			q.y=punpm->P.Z;	q.x=(Q.Z-Q.Y*q.y)/Q.X;}
				if(abs(Q.X)>abs(Q.Y)){fden=-1.F/parciales[6]; malox=2;}
				else{fden=-1.F/parciales[7]; malox=1;}
				if(*pmalo!=malox){
					*pmalo=malox;
					if(malox==1) punpm->P.Z=q.x;
					else punpm->P.Z=q.y;
				}
			#else
				*pL++=0;	*pL++=0;
				*pLb++=-(float)(Q.X*q.x+Q.Y*q.y-Q.Z)*fden;
				*pLb++=0;
			#endif
				Puntoxy_float qf;

				qf.x=(float)q.x*fden;
				qf.y=(float)q.y*fden;

				parciales[0]=-rf.Y*fden-rf.Z*qf.y;
				parciales[1]=rf.Z*qf.x+rf.X*fden;
				parciales[2]=rf.X*qf.y-rf.Y*qf.x;
				parciales[3]=(float)Pg.Z*qf.y+(float)Pg.Y*fden;
				parciales[4]=-(float)Pg.X*fden-(float)Pg.Z*qf.x;
				parciales[5]=(float)Pg.Y*qf.x-(float)Pg.X*qf.y;

				pB+=6;
			#ifndef COPL
				float faux,fauxb;
				faux=fM[0][0]*parciales[3]+fM[1][0]*parciales[4]+fM[2][0]*parciales[5];
				fauxb=fM[0][1]*parciales[3]+fM[1][1]*parciales[4]+fM[2][1]*parciales[5];
				if(malox==1){
					{float *ipA=pA; fordown(it,5,ipA+=n2) *ipA=0;}
					*pBb++=0;	*pBb++=faux;
					*pBb++=0;	*pBb++=fauxb;
					*pBb++=1;	*pBb++=parciales[6]*fden;
				}else{
					{float *ipA=pA+1; fordown(it,5,ipA+=n2) *ipA=0;}
					*pBb++=0;	*pBb++=faux;
					*pBb++=0;	*pBb++=fauxb;
					*pBb++=1;	*pBb++=parciales[7]*fden;
				}
			#else
				pBb+=6;
			#endif

				_ncopl(if(malox==1) pA++;)
				float *ipA=pA;
				if(esx>0) *ipA=parciales[0];	else *ipA=parciales[1];	ipA+=n2;
				if(esx>1) *ipA=parciales[1];	else *ipA=parciales[2];	ipA+=n2;
				*ipA=-fGM.Z*parciales[1]+fGM.Y*parciales[2]-rf.Z*parciales[4]+rf.Y*parciales[5];	ipA+=n2;
				*ipA=fGM.Z*parciales[0]-fGM.X*parciales[2]+rf.Z*parciales[3]-rf.X*parciales[5];		ipA+=n2;
				*ipA=-fGM.Y*parciales[0]+fGM.X*parciales[1]-rf.Y*parciales[3]+rf.X*parciales[4];

				_ncopl(if(malox==2)) pA++;
				pA++;
			}
		#ifndef COPL
			*pL++=(float)(punp->x-p.x);
			*pL++=(float)(punp->y-p.y);	punp++;
			*pLb++=(float)(punp->x-q.x);
			*pLb++=(float)(punp->y-q.y);	punp++;
		#endif
		}}//Fin Matrices A y L;
	//Criterio de convergencia
		vv=0;
		{durchlaufei(float,L,n<<2) vv+=*ptr**ptr;}
		if(!isfinite_f(vv)) break;
		if(iter>1){
			if(n==5){
				if(iter==3) break;
			}else{
				float faux=fabsf(vvant-vv);
				if(faux<vv)break;
			}
		}
		vvant=vv;
	//Matriz N
		//Bloque fot$fot
		uint l=0;
		float *pAb=A;
		for(cint i=5;i;l+=6,pAb+=n2){
			float *pAc=pAb;
			float *p_b=pAb;
			float *p_a=Nf+l;
			for(cint j=i--;j--;){
				float faux=0;
				inner_loopn(n2,kt, faux+=*p_b++**pAc++);
				p_b-=n2;
				*p_a++=faux;
		}	}
		//Bloque coord$coord
		{float *pNp=Np[0];
		float *pB=B[0], *pBb=B[n];
		fordowni(n,){
			for(cint j=3;j;){
				uint j2=j+j--;
				for(uint kk=0;kk<j2;){
					float faux;
					faux=pB[0]*pB[kk];
					faux+=pB[1]*pB[kk+1];
					faux+=pBb[0]*pBb[kk++];
					faux+=pBb[1]*pBb[kk++];
					*pNp++=faux;
				}
				pNp+=3-j;
				pB+=2, pBb+=2;
			}
			pNp-=3;
		}}
		//Bloque fot$coord
		{float *pN=Nfp, *pA=A;
		fordowni(5,){
			float *pB=B[n];
			fordownj(n,){
				float faux,fauxb;
				faux=*pA++;		fauxb=*pA++;
				*pN=faux**pB++;	*pN+++=fauxb**pB++;
				*pN=faux**pB++;	*pN+++=fauxb**pB++;
				*pN=faux**pB++;	*pN+++=fauxb**pB++;
			}
		}}

		//Inversin de Np
		{float *pN=Np[0];
		fordowni(n,pN+=9){
		#ifdef COPL
			if(malo[i]) continue;
		#endif
			invcho_3(pN);
		}}
		//Matriz Afp
		{float *pAfp=Afp;
		float *pNfp=Nfp;
		fordowni(5,){
			float *pNp=Np[0];
			uint k=2;
			fordownj(n3,){
				float faux=*pNfp++**pNp++;
				faux+=*pNfp++**pNp++;
				faux+=*pNfp**pNp++;
				if(k==0){pNfp++; k=2;}
				else{pNfp-=2; k--;}
				*pAfp++=-faux;
			}
		}}
		//Matriz Nf+
		mmul_11(float,Nf,+=,Nfp,Afp,5,n3,5);
		invcho(Nf,5);

	//Matriz AtL;
		{float *pA=A;
		 float *pL=L+n2, *pAtLf=AtLf;
		fordowni(5,pAtLf++){
			float faux=0;
			inner_loopn(n2,jt, faux+=*pA++**pL++);
			pL-=n2;
			*pAtLf=faux;
		}}
		{float *pB1=B[0], *pB2=B[n];
		float *pL1=L, *pL2=L+n2;
		float *pAtLp=AtLp;
		fordowni(n,(pL1+=2,pL2+=2)){
			fordownj(3,pAtLp++){
				*pAtLp=*pB1++**pL1;
				*pAtLp+=*pB1++**(pL1+1);
				*pAtLp+=*pB2++**pL2;
				*pAtLp+=*pB2++**(pL2+1);
		}	}
		}
	//Atlf+
		{float *pAtLf=AtLf;
		float *pAfp=Afp;
		fordowni(5,pAtLf++){
			float *pAtp=AtLp;
			float faux=0;
			inner_loopn(n3,jt, faux+=*pAfp++**pAtp++);
			*pAtLf+=faux;
		}}
	//DX
		{float *pDXf=DXf;
		float *pNf=Nf;
		fordowni(5,pDXf++){
			float *pAtLf=AtLf;
			float faux=0;
			inner_loopN(5,jt, faux+=*pNf++**pAtLf++);
			*pDXf=faux;
		}}
		//DXp
		{float *pNp=Np[0];
		float *pAtLp=AtLp;
		float *pDXp=DXp;
		fordowni(n,pAtLp+=3){
			fordownj(3,pDXp++){
				float faux=*pNp++*pAtLp[0];
				faux+=*pNp++*pAtLp[1];
				faux+=*pNp++*pAtLp[2];
				*pDXp=faux;
			}
		}}
		//DXp2
		{float *pDXf=DXf;
		float *pAfp=Afp;
		for(cint i=5;i--;pDXf++){
			float auxb=*pDXf;
			float *pDXp=DXp;
			inner_loopn(n3,jt, *pDXp+++=*pAfp++*auxb);
		}}
		//fin matrices

		if(esx>0) c.P.X+=DXf[0];	else c.P.Y+=DXf[0];
		if(esx>1) c.P.Y+=DXf[1];	else c.P.Z+=DXf[1];
		{double MD[3][3], MT[3][3];
		MatrizDelta(*(PuntoXYZ_float*)(DXf+2),MD);
		mmulrot(MD,c.M,MT);
		memcpy_double(c.M,MT,9);}
		{float *pDX=DXp;
		durchVectori(PuntoM,mod.puntos){
			ptr->P.X+=*pDX++;
			ptr->P.Y+=*pDX++;
			ptr->P.Z+=*pDX++;
		}}
		/*//Valores mximos;
		if(max2!=NULL){
			maxg[0]=maxg[1];
			maxg[1]=maxg[2];
			maxim=fabsf(DXf[2]);
			{float faux=fabsf(DXf[3]);	if(faux>maxim) maxim=faux;}
			{float faux=fabsf(DXf[4]);	if(faux>maxim) maxim=faux;}
			maxg[2]=maxim;
		}
		if(max1!=NULL){
			maxX[0]=maxX[1];
			maxX[1]=maxX[2];
			maxim=fabsf(DXf[0]);
			{float faux=fabsf(DXf[1]);	if(faux>maxim) maxim=faux;}
			for(uint i=0;i<n3;i++){
				float faux=fabsf(DXp[i]);	if(faux>maxim) maxim=faux;
			}
			maxX[2]=maxim;
		}*/
	}
/*********Fin proceso iterativo;**************/
	{PuntoXYZ_double Q=c.P;
	c.P.X=c.M[0][0]*Q.X+c.M[1][0]*Q.Y+c.M[2][0]*Q.Z;
	c.P.Y=c.M[0][1]*Q.X+c.M[1][1]*Q.Y+c.M[2][1]*Q.Z;
	c.P.Z=c.M[0][2]*Q.X+c.M[1][2]*Q.Y+c.M[2][2]*Q.Z;}
	c.P+=CG;
	mod.centros.ppio[1]=c;

	//Clculo de las coordenadas de los puntos malos y lista de fpuntosm
	{Puntofx pmv;
	PuntoXYZ_double const a={0,0,0};
	PuntoXYZ_double b;
	//pmv.nfotos=2;
	pmv.fp[0].f=0;
	pmv.fp[1].f=1;
	b.Z=-1.0;
	PuntoM *punpm=mod.puntos.ppio;
	Puntoxy_double *ptr=comun12;
	for(uint i=0;i<n;i++,punpm++){
		if(!malo[i]) continue;
		PuntoXYZ_double d;
		b.X=ptr->x;
		b.Y=ptr++->y;
		d.X=ptr->x;
		d.Y=ptr++->y;
		d.Z=-1.0;
		d=GiraPunto_inv(d,c.M);
		punpm->den=secrr3_ap_foto(a,b,c.P,d,&punpm->P);
		if(punpm->den<TOL_FF){
			if(punpm->den>0.9F*TOL_FF) punpm->den=0.9F*TOL_FF;	//in case the comparision is carried in another machine
			pmv.n=punpm->index;													//(the model is returned and may be used elsewhere)
			pmv.npunto=i;
			pmv.fp[0].p=ind_com[i];
			pmv.fp[1].p=ind_com2[i];
			Vadd(mod.fpuntosm,Puntofx,pmv);
		}
	}}

	/*if(max1){
		max1[0]=maxX[0];
		max1[1]=maxX[1];
		max1[2]=maxX[2];
	}
	if(max2){
		max2[0]=maxg[0];
		max2[1]=maxg[1];
		max2[2]=maxg[2];
	}*/
	result->iter=iter;

	{uint k=n-5;
	float faux=vmin*vmin*k;
	if(vv>faux) faux=vv;
	if(k) vv/=k;
	else vv=0;
	vv=sqrt(vv);
	result->vv=vv*(float)fot1->focal;
	faux/=n;
	faux=sqrtf(faux);
	faux*=3;
	result->vmal=0;
	if(k){
		durchlaufei(float,L,n2){
			if(fabsf(*ptr)>faux) result->vmal++;
		}
		result->prop_vmal=(float)result->vmal/k;
	}
	else result->prop_vmal=0;
	}
	result->nret=0;
	if(!isfinite_f(vv)) result->nret=1;

	remove_from_delete_Modelo(&mod);
	myreturn mod;

salida_outofmem:
	result->nret=-2; myreturn mod;
}
#undef np2
