////////////////////////////////////////////////////////////////////////////////////////
//　　Ver.0.1 beta1                                                                       //
////////////////////////////////////////////////////////////////////////////////////////
/*
[出力Debugは任意]

---------------汎用関数(局所,個所関数で構成される)-------------------

NO汎用加算　Addb(A,B)　→A+Bを返す
NO汎用減算　Subb(A,B)　→A-Bを返す
NO汎用乗算　Mulb(A,B)　→A*Bを返す


---------------局所関数(自然数のみを扱う)---------------------

OK自然数加算　Add_min(A,B,Debug)　→A+Bを返す,Debug
OK自然数減算　Sub_min(A,B,Debug)　→A-Bを返す,Debug
OK自然数乗算　Mul_min(A,B,Debug)　→A*Bを返す,Debug
OK自然数除算[余なし]　Divd_min(A,B)　→A/Bの商
NO自然数除算[余]　Divd(A,B)　→A/Bの商,余り
NO自然数除算[∞]　Divx(A,B,C)　→A/Bを小数点以下C桁まで実行


---------------特殊関数(特殊計算を行う)-------------------------

OK累乗　Invo(A,B,Debug)　→A^Bを返す,Debug
OK階乗　Fact(A,Debug)　→A!を返す,Debug
OK平方数　SqrtD(A,B,Debug)　→√(A)をB小数点以下桁計算し返す,Debug
OK円周率　F_PI(A)　円周率を小数点以下A桁計算,Debug


---------------個所関数(細かい動作を行う)-----------------------

OK小数点除去　DelDeci(A)　→小数点を取り除いたA,後ろから数えた小数点の位置
OK10桁区切　OnCut(A)　→10桁ごとに区切って出力
OK区切解除　UnCut(A)　→10桁ごとの区切りを解除
OK数値比較　Er(A,B)　→絶対値が大きいほうを返す


*/

//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■　局　所　関　数　　　局　所　関　数　　　　局　所　関　数　　　　局　所　関　数　■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　自然数加算　Add_min
////////////////////////////////////////////////////////////////////////////////////////
Add_min = function (A,B){
	
	
	var A_2=A;
	var B_2=B;
	if(A.length < B.length){
		A_2=B;
		B_2=A;
	}
	
	var Up=0;
	var C="";
	//桁数揃え
		switch(A_2.length%15){
			case 14: A_2="0"              +A_2;break;
			case 13: A_2="00"             +A_2;break;
			case 12: A_2="000"            +A_2;break;
			case 11: A_2="0000"           +A_2;break;
			case 10: A_2="00000"          +A_2;break;
			case  9: A_2="000000"         +A_2;break;
			case  8: A_2="0000000"        +A_2;break;
			case  7: A_2="00000000"       +A_2;break;
			case  6: A_2="000000000"      +A_2;break;
			case  5: A_2="0000000000"     +A_2;break;
			case  4: A_2="00000000000"    +A_2;break;
			case  3: A_2="000000000000"   +A_2;break;
			case  2: A_2="0000000000000"  +A_2;break;
			case  1: A_2="00000000000000" +A_2;break;
			default: A_2=A_2;
	}
		switch(B_2.length%15){
			case 14: B_2="0"              +B_2;break;
			case 13: B_2="00"             +B_2;break;
			case 12: B_2="000"            +B_2;break;
			case 11: B_2="0000"           +B_2;break;
			case 10: B_2="00000"          +B_2;break;
			case  9: B_2="000000"         +B_2;break;
			case  8: B_2="0000000"        +B_2;break;
			case  7: B_2="00000000"       +B_2;break;
			case  6: B_2="000000000"      +B_2;break;
			case  5: B_2="0000000000"     +B_2;break;
			case  4: B_2="00000000000"    +B_2;break;
			case  3: B_2="000000000000"   +B_2;break;
			case  2: B_2="0000000000000"  +B_2;break;
			case  1: B_2="00000000000000" +B_2;break;
			default: B_2=B_2;
	}
	var limit = A_2.length/15;
	
	//加算
	for(addlim=1;addlim<=limit;addlim++){
		var A_X = A_2.substr(A_2.length-addlim*15,15);
		
		if(addlim*15 > B_2.length){
			var B_X="0";
			//Bが今後0,繰り上がりが0のとき計算を中止
			if(Up==0){
				C= A_2.substr(0,A_2.length-addlim*15+15)+C;
				z=1;
				while(z==1){
					if(C.charAt(0)=="0"){C=C.substr(1,C.length-1);}else{break;}
				}
				if(C==""){C="0";}
				return C;
			}
			
		}else{
			var B_X = B_2.substr(B_2.length-addlim*15,15);
		}
		var APB = parseFloat(A_X)+parseFloat(B_X)+Up;
		if(String(APB).length==16){
			APB = String(APB).substr(1,15);
			Up=1;
		}else{
			Up=0;
		}
		switch(String(APB).length%15){
			case 14: C="0"              +APB+C;break;
			case 13: C="00"             +APB+C;break;
			case 12: C="000"            +APB+C;break;
			case 11: C="0000"           +APB+C;break;
			case 10: C="00000"          +APB+C;break;
			case  9: C="000000"         +APB+C;break;
			case  8: C="0000000"        +APB+C;break;
			case  7: C="00000000"       +APB+C;break;
			case  6: C="000000000"      +APB+C;break;
			case  5: C="0000000000"     +APB+C;break;
			case  4: C="00000000000"    +APB+C;break;
			case  3: C="000000000000"   +APB+C;break;
			case  2: C="0000000000000"  +APB+C;break;
			case  1: C="00000000000000" +APB+C;break;
			default: C=APB+C;
		}
		APB=null;
	}
	C = Up+C;
	
	z=1;
	while(z==1){
		if(C.charAt(0)=="0"){C=C.substr(1,C.length-1);}else{break;}
	}
	if(C==""){C="0";}
	
	return C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　自然数減算　Sub_min
////////////////////////////////////////////////////////////////////////////////////////
Sub_min = function (A,B){
	
	
	if(Er(A,B)){
		var Mark="";
		var A_2=A;
		var B_2=B;
	}else{
		var Mark="-";
		var A_2=B;
		var B_2=A;
	}
	
	var Up=0;
	var C="";
	
	
	//桁数揃え
		switch(A_2.length%15){
			case 14: A_2="0"              +A_2;break;
			case 13: A_2="00"             +A_2;break;
			case 12: A_2="000"            +A_2;break;
			case 11: A_2="0000"           +A_2;break;
			case 10: A_2="00000"          +A_2;break;
			case  9: A_2="000000"         +A_2;break;
			case  8: A_2="0000000"        +A_2;break;
			case  7: A_2="00000000"       +A_2;break;
			case  6: A_2="000000000"      +A_2;break;
			case  5: A_2="0000000000"     +A_2;break;
			case  4: A_2="00000000000"    +A_2;break;
			case  3: A_2="000000000000"   +A_2;break;
			case  2: A_2="0000000000000"  +A_2;break;
			case  1: A_2="00000000000000" +A_2;
			default: A_2=A_2;
	}
		switch(B_2.length%15){
			case 14: B_2="0"              +B_2;break;
			case 13: B_2="00"             +B_2;break;
			case 12: B_2="000"            +B_2;break;
			case 11: B_2="0000"           +B_2;break;
			case 10: B_2="00000"          +B_2;break;
			case  9: B_2="000000"         +B_2;break;
			case  8: B_2="0000000"        +B_2;break;
			case  7: B_2="00000000"       +B_2;break;
			case  6: B_2="000000000"      +B_2;break;
			case  5: B_2="0000000000"     +B_2;break;
			case  4: B_2="00000000000"    +B_2;break;
			case  3: B_2="000000000000"   +B_2;break;
			case  2: B_2="0000000000000"  +B_2;break;
			case  1: B_2="00000000000000" +B_2;
			default: B_2=B_2;
	}
	var limit = A_2.length/15;
	
	
	//減算
	for(addlim=1;addlim<=limit;addlim++){
		var A_X = A_2.substr(A_2.length-addlim*15,15);
		
		if(addlim*15 > B_2.length){
			B_X="0";
		}else{
			var B_X = B_2.substr(B_2.length-addlim*15,15);
		}
		var APB = parseFloat(A_X)-parseFloat(B_X)-Up;
		if(APB<0){
			APB=1000000000000000+APB;
			Up=1;
		}else{
			Up=0;
		}
		switch(String(APB).length%15){
			case 14: APB="0"              +APB;break;
			case 13: APB="00"             +APB;break;
			case 12: APB="000"            +APB;break;
			case 11: APB="0000"           +APB;break;
			case 10: APB="00000"          +APB;break;
			case  9: APB="000000"         +APB;break;
			case  8: APB="0000000"        +APB;break;
			case  7: APB="00000000"       +APB;break;
			case  6: APB="000000000"      +APB;break;
			case  5: APB="0000000000"     +APB;break;
			case  4: APB="00000000000"    +APB;break;
			case  3: APB="000000000000"   +APB;break;
			case  2: APB="0000000000000"  +APB;break;
			case  1: APB="00000000000000" +APB;
			default: APB=APB;
		}
		
		C = String(APB)+C;
		delete APB;
	}
	
	z=1;
	while(z==1){
		if(String(C).charAt(0)=="0"){C=C.substr(1,C.length-1);}else{break;}
	}
	if(C==""){C="0";}
	C=Mark+C;
	return C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　自然数乗算　Mul_min
////////////////////////////////////////////////////////////////////////////////////////
Mul_min = function (Ad,Bd){
	
		switch(Ad.length%8){
			case  7: A="0"       +Ad;break;
			case  6: A="00"      +Ad;break;
			case  5: A="000"     +Ad;break;
			case  4: A="0000"    +Ad;break;
			case  3: A="00000"   +Ad;break;
			case  2: A="000000"  +Ad;break;
			case  1: A="0000000" +Ad;break;
			default: A=Ad;
	}
		switch(Bd.length%7){
			case  6: B="0"       +Bd;break;
			case  5: B="00"      +Bd;break;
			case  4: B="000"     +Bd;break;
			case  3: B="0000"    +Bd;break;
			case  2: B="00000"   +Bd;break;
			case  1: B="000000"  +Bd;break;
			default: B=Bd;
	}
	//8,7桁区切りの計算の最大数
	var limitA = A.length/8;
	var limitB = B.length/7;
	var AB = "0";
	
	for(A_Loop=0;A_Loop<limitA;A_Loop++){
		var Multiplication_A = A.substr(A_Loop*8,8);
		
		if(parseFloat(Multiplication_A)!=0){
		var A_Zero="";
			for(Loop_A_Zero=0 ; Loop_A_Zero<(limitA-A_Loop-1) ; Loop_A_Zero++){
				A_Zero+="00000000";
			}
		}
		for(B_Loop=0;B_Loop<limitB;B_Loop++){
		//	var Multiplication_B = B.substr(B_Loop*7,7);
			
			var AB_1 = String(parseFloat(Multiplication_A)*parseFloat(Multiplication_B = B.substr(B_Loop*7,7)));
			if(AB_1!="0"){
				var B_Zero="";
				for(Loop_B_Zero=0 ; Loop_B_Zero<(limitB-B_Loop-1) ; Loop_B_Zero++){
					B_Zero+="0000000";
				}
				var AB_2 = AB_1+A_Zero+B_Zero;
				AB=Add_min(AB,AB_2);
			}
		}
	}
	
	
	var C=AB;
	
	
	return C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　自然数除算[余り]　Divd_min　A/B=商
////////////////////////////////////////////////////////////////////////////////////////
Divd_min = function (A,B){
	if(B=="0")return false;
	var C ="";//商
	//割る数をリストアップ
	var Divd0_9 = "0,"+B;
	var Bd2 = B;
	for(i=2;i<=10;i++){
		Bd2=Add_min(B,Bd2);
		Divd0_9+=","+Bd2;
	}
	//ゼロの個数をリストアップ
	var Zero = "";
	for(i=0;i<=(A.length-B.length);i++){
		Zero+="0";
	}
	var c = "";
	var b = B;
	var a = A;
	while(Er(a,b)){
		Zero = Zero.substr(0,Zero.length-1);
		for(i=1;i<=10;i++){
			var Now = Divd0_9.split(",")[i]+Zero;
			if(!Er(a,Now)){
				var Now2 = Divd0_9.split(",")[i-1]+Zero
				a = Sub_min(a,Now2);
				c+=(i-1);
				break;
			}
		}
	}
	c=c+Zero;
	z=1;
	while(z==1){
		if(String(c).charAt(0)=="0"){c=c.substr(1,c.length-1);}else{break;}
	}
	if(c==""){c="0";}
	
	return c;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■　特　殊　関　数　　　特　殊　関　数　　　　特　殊　関　数　　　　特　殊　関　数　■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　階乗関数 Fact
////////////////////////////////////////////////////////////////////////////////////////
Fact = function (String){
				var Debug="";
				Start= new Date;
				var time=Start.getTime();
				var Start=time;
var String_flow = "1";
var String_Factorial="1";
var Zero="";
var Zerop="";
for(Lv1=0;Lv1<Math.round(eval(String)/100);Lv1++){
	for(Lv2=(Lv1*100+1);Lv2<(Lv1*100+101);Lv2++){
		while(String_Factorial.charAt(String_Factorial.length-1)=="0"){
			String_Factorial=String_Factorial.substr(0,String_Factorial.length-1);
			Zerop+="0";
		}
		String_Factorial=Mul_min(String_Factorial,(Lv2+""));
		status=Lv2;
	}
		var End1= new Date;
		Debug+=(Lv1*100+1)+"~"+(Lv1*100+100)+":"+(End1.getTime()-time)/1000+"sec ("+(String_Factorial.length+Zerop.length)+"-length)\n(Zero:"+Zerop.length+")\n"
		time=End1.getTime();
	Zero+=Zerop;
	Zerop="";
	if(String_flow!="1"){
		String_flow=Mul_min(String_flow,String_Factorial);
	}else{
		String_flow=String_Factorial;
	}
	String_Factorial="1";
		var End2= new Date;
		Debug+="*:"+(End2.getTime()-time)/1000+"sec\n"
		time=End2.getTime();
}
				End= new Date;
				time=(End.getTime()-Start)/1000;

var Factorial_C = String_flow+Zero+",\n---Cost---\n"+Debug+"Total Cost:"+time+"sec";
return Factorial_C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　累乗関数 Invo
////////////////////////////////////////////////////////////////////////////////////////
Invo = function (A,B,Debugs){
	var Debug = "";
				Start= new Date;
				var time=Start.getTime();
				var Start=Start.getTime();
	if(eval(B)>3){
		
		var Invo_Memory="1";
		var Invo_length=0;
		var now_Invo=1;
		var Last_Invo=eval(B);
		
		var Math_Memory=String(A);
		var now_Math=String(A);
		var Invo_all = "1"
		
		while(now_Invo*2<=Last_Invo){
			now_Invo = now_Invo*2;
			Invo_Memory+=","+now_Invo;
			Invo_length++;
		}
				End1= new Date;
				Debug+="最大累乗"+now_Invo+"-計算終了:"+((End1.getTime()-time)/1000)+"sec\n";
				time=End1.getTime();
				status="Max:"+now_Invo;
		
		
		for(i=1;i<=Invo_length;i++){
		status="make List..."+(Invo_length-i);
		now_Math=Mul_min(now_Math,now_Math,"1");
		Math_Memory+=","+now_Math;
		}
				End2= new Date;
				Debug+=A+"^"+now_Invo+"-計算終了:"+((End2.getTime()-time)/1000)+"sec\n";
				time=End2.getTime();		
		
		Invo_all=now_Math;
		var memori = ""+now_Math;
		Last_Invo-=eval(Invo_Memory.split(",")[Invo_length]);
		while(Last_Invo>0){
			for(i=0;i<Invo_length;i++){
				if((eval(Invo_Memory.split(",")[i])*2)>Last_Invo){
					status="*"+A+"^"+Invo_Memory.split(",")[i];
					Last_Invo-=eval(Invo_Memory.split(",")[i]);
					Invo_all = Mul_min(Invo_all,Math_Memory.split(",")[i]);
					memori+="*"+Math_Memory.split(",")[i];
					break;
				}
			}
		}
	}
	if(eval(B)==3){var Invo_all = Mul_min(A,Mul_min(A,A,"1"));}
	if(eval(B)==2){var Invo_all = Mul_min(A,A);}
	if(eval(B)==1){var Invo_all = A;}
	if(eval(B)==0){var Invo_all = 1;}
				End= new Date;
				Debug+="全ての乗算終了:"+((End.getTime()-time)/1000)+"sec\n";
				time=(End.getTime()-Start)/1000;
				
	if(eval(Debugs)==0){var C=Invo_all;}else{var C = Invo_all+",\n---Cost---\n"+Debug+"Total Cost:"+time+"sec";}
return C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　平方関数 SqrtD
////////////////////////////////////////////////////////////////////////////////////////
SqrtD = function (A,B,Debug){

	if(Debug=="0"){
		Start= new Date;
		var time=Start.getTime();
	}
	if(Math.pow(String(Math.sqrt(A)).split(".")[0],2)==eval(A)){
		return Math.sqrt(A)+",0";
	}
	if(eval(B)>14){
		var D_sqrt_length=15;
	}else{
		if(Debug=="0"){
			return String(Math.sqrt(A)).substr(0,String(Math.sqrt(A)).length-17+eval(B))+",\n\nCost:0sec";
		}else{
			return String(Math.sqrt(A)).substr(0,String(Math.sqrt(A)).length-17+eval(B));
		}
	}
	var D_sqrt = String(Math.sqrt(eval(A))*10000000000000000).substr(0,D_sqrt_length);
	while(eval(String(Math.pow(eval(D_sqrt),2)).substr(0,A.length))>eval(A)){
		D_sqrt =　D_sqrt.substr(0,D_sqrt.length-1);
	}
	
	while(D_sqrt.length<eval(B)){
		status=D_sqrt.length;
		for(i=1;i<10;i++){
			var D_sqrt_now = D_sqrt+String(i);
			
			if( eval(Mul_min(D_sqrt_now,D_sqrt_now).substr(0,A.length)) >= eval(A) ){
				D_sqrt+=String(i-1);
				break;
			}else{
				if(i==9){
					D_sqrt+=String(i);
					break;
				}
			}
		}
	}
	var C = D_sqrt;
	//右側の0を除去
	while(C.charAt(C.length-1)=="0" && C.length>A.length){
		C = parseFloat(C.substr(0,15))+C.substr(15,C.length-15);
	}
	C = C.substr(0,String(Math.round(Math.sqrt(A))).length)+"."+C.substr(String(Math.round(Math.sqrt(A))).length,C.length);
	if(Debug=="0"){
		End= new Date;
		var time=(End.getTime()-time)/1000;
		C+=",\n\nCost:"+time+"sec";
	}
	return C;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　円周率関数　PI　A(桁数) →　3.14....
////////////////////////////////////////////////////////////////////////////////////////
F_PI = function(A){
	
	Start= new Date;
	var time=Start.getTime();
	DEBUG="";
	
	var Zero="";
	for(i=0;i<eval(A);i++){
	Zero+="0";
	}
	var PI = "0";
	var past_PI = "x";
	var Count=0;
	while(PI!=past_PI){
		past_PI = PI;
		var n21 = String(Count*2+1);
		var n22 = String(Count*2+3);
		var Plus1 = Divd_min((4+Zero),(Mul_min(n21,Invo("5",n21,"0"))));
		var Plus2 = Divd_min((1+Zero),(Mul_min(n22,Invo("239",n22,"0"))));
		var Minus1 = Divd_min((4+Zero),(Mul_min(n22,Invo("5",n22,"0"))));
		var Minus2 =Divd_min((1+Zero),(Mul_min(n21,Invo("239",n21,"0"))));
		var Plus = Add_min(Plus1,Plus2);
		var Minus = Add_min(Minus1,Minus2);
		PI = Add_min(PI,Mul_min("4",Sub_min(Plus,Minus)));
		Count++;
		Count++;
	}
	
	End= new Date;
	time=(End.getTime()-time)/1000;
	PI+=",\n\nCost:"+time+"sec\n"+DEBUG;
	
	return PI;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■　個　所　関　数　　　個　所　関　数　　　　個　所　関　数　　　　個　所　関　数　■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　小数点除去　DelDeci
////////////////////////////////////////////////////////////////////////////////////////
DelDeci = function (Math_String){
	
	
	
	//符号除去,Mark=除去した符号;
	if(Math_String.charAt(0)=="-"){
		var Math_String_abs = Math_String.substr(1,Math_String.length-1);
		var Mark = "-";
	}else{
		var Math_String_abs = Math_String;
		var Mark = "";
	}
	
	
	//小数点位置検索
	
	//演算速度を上げるために小数点の有無をチェック
	if(!Math_String_abs.match(/\./)){var Decimal_Point_Position=0;var Math_String_NoPoint=Mark+Math_String_abs;}//存在しない場合
	else{
	//小数点が存在した場合の位置特定
		
		var Decimal_Point_Position=Math_String_abs.length-1-Math_String_abs.indexOf(".",0);
		
		//小数点除去
		var Math_String_NoPoint=Mark+Math_String_abs.replace(/\./,"");
		
	}
	//小数点を外した数,小数点の位置を返す
	var return_Point_String=Math_String_NoPoint+","+Decimal_Point_Position;
	
	
	
	return return_Point_String;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　10桁区切　OnCut
////////////////////////////////////////////////////////////////////////////////////////
OnCut = function (String){
	
	var limit = String.length%10;
	var String2=String.substr(limit-1,String.length);
	var String3=String.substr(0,limit-1);
	while(String3.length<9){
		String3=" "+String3;
	}
	for(Cut=0;Cut<String2.length;Cut++){
		String3+=String2.charAt(Cut);
		if(Cut%10==0){String3+=" ";}
	}
	return String3;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　区切解除　UnCut
////////////////////////////////////////////////////////////////////////////////////////
UnCut = function (String){
	
	var String2=String.replace(/ /,"");
	while(String2.match(" ")){
		String2=String2.replace(/ /,"");
	}
	return String2;
}
//■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
//　比較関数　Er
////////////////////////////////////////////////////////////////////////////////////////
Er = function(AD,BD){
	var A = AD;
	var B = BD;
	z=1;
	while(z==1){
		if(A.charAt(0)=="0"){A=A.substr(1,A.length-1);}else{break;}
	}
	if(A==""){A="0";}
	z=1;
	while(z==1){
		if(B.charAt(0)=="0"){B=B.substr(1,B.length-1);}else{break;}
	}
	if(B==""){B="0";}
	
	if(A.length > B.length){
		return true;
	}
	if(A.length < B.length){
		return false;
	}
	if(A.length==B.length){
		
		if(A==B){
			return true;
		}else{
			for(er=0;er<A.length;er++){
				if(A.charAt(er)!=B.charAt(er)){
					if(eval(A.charAt(er))>eval(B.charAt(er))){
						return true;
					}else{
						return false;
					}
				}
			}
		}
	}
}