abstype ArbInt = Node of (int * int list) 



with 



exception DivisionbyZero;

exception InvalidNumber;



local

fun Parcala x=if x=0 then nil else (x mod 10)::Parcala(x div 10);

fun delheadspace mystlist=if hd(mystlist)= #" " then delheadspace(tl mystlist) else mystlist;

fun invertlist(nil)=nil |

        invertlist(x::xs)=(invertlist xs)@[x];

fun chltointl mylist=if mylist=nil then nil else (ord(hd mylist)-48)::chltointl(tl mylist);

fun intltochl mylist=if mylist=nil then nil else chr(hd(mylist)+48)::intltochl(tl mylist);

fun existError(nil)=1 |

	existError(x::xs)=if(ord(x)>=48 andalso ord(x)<=57) then existError(xs) else raise InvalidNumber;

fun delzeros(nil) =nil |

        delzeros(x::xs)= if x=0 then (delzeros xs) else x::xs;

fun delheadzeros myintlist=invertlist(delzeros(invertlist(myintlist)));

fun sizeoflist lst= if lst=nil then 0 else 1+sizeoflist(tl lst);

fun Comp1vs2(nil,nil)=false |

	Comp1vs2(x::xs,y::ys)=if x>y then true else if x<y then false else Comp1vs2(xs,ys);

fun isBigger(lst1,lst2)=let

			val size1=sizeoflist(lst1);

			val size2=sizeoflist(lst2)

			in

			if size1>size2 then true else if size1<size2 then false 

				else Comp1vs2(invertlist(lst1),invertlist(lst2))

			end;

fun absval(x:int*int list) = (1, #2(x));

fun Topla(nil,nil,elde)=if elde=0 then nil else [elde] |

	Topla(nil,x::xs,elde)= ((x + elde) mod 10)::Topla(nil,xs,(x+elde) div 10) |

	Topla(x::xs,nil,elde)= ((x+elde) mod 10)::Topla(xs,nil,(x+elde) div 10) |

	Topla(x::xs,y::ys,elde)=((x+y+elde) mod 10)::Topla(xs,ys,(x+y+elde) div 10);



fun Cikar(nil,nil,aldik)=nil |

	Cikar(x::xs,nil,aldik)=if x-aldik<0 then (10+x-aldik)::Cikar(xs,nil,1)

							else (x-aldik)::Cikar(xs,nil,0) |

	Cikar(x::xs,y::ys,aldik)=if x-aldik-y<0 then (10+x-aldik-y)::Cikar(xs,ys,1)

							else (x-aldik-y)::Cikar(xs,ys,0);

fun getzeros(deg)=if deg<=0 then nil else 0::getzeros(deg-1);

fun Carp2(nil,mult,elde)=if elde=0 then nil else [elde] |

	Carp2(x::xs,mult,elde)= ((x*mult+elde) mod 10)::Carp2(xs,mult,(x*mult+elde) div 10);



fun Carp(lstx,nil,deg)= nil |

	Carp(lstx,y::ys,deg)=Topla(getzeros(deg)@Carp2(lstx,y,0),Carp(lstx,ys,deg+1),0);



fun getUstSinir(lstx,lsty,k)=

	if isBigger(getzeros(k) @lsty ,lstx) then k else getUstSinir(lstx,lsty,k+1);



fun myGetMem(lstx,lsty,numofzeros,k)=if isBigger(Carp(lsty,getzeros(numofzeros)@[k],0),lstx) then k-1

	else myGetMem(lstx,lsty,numofzeros,k+1);

	



fun Bol(mysign,lstx,lsty,ustsinir)=let

	val newmem=myGetMem(lstx,lsty,ustsinir-1,1)	

	in

	if ustsinir>1 then 

	newmem::Bol(mysign,delheadzeros(Cikar(lstx,Carp(lsty,getzeros(ustsinir-1)@[newmem],0),0)),lsty,ustsinir-1)	

 		else if mysign= ~1 andalso delheadzeros(Cikar(lstx,Carp(lsty,[newmem],0),0))<>nil then [newmem+1]			

			else [newmem]

	end;





in

fun fromInt x=let

	val mysign=if x<0 then ~1 else 1;

	val mynumlist=if mysign<0 then Parcala(~x) else Parcala(x)

	in

	Node(mysign,mynumlist)

	end;



fun fromString myst=let 

	val headfree=delheadspace(explode myst);

	val mysign=if hd(headfree)= #"~" then ~1 else 1;

	val tailfree=if mysign<0 then  delheadspace(invertlist (tl headfree))

				else delheadspace(invertlist headfree);

	val myerror=existError(tailfree);

	val myintlist=chltointl(tailfree);

	val myintlist=delheadzeros myintlist

	in

	Node(mysign,myintlist)

	end;



fun toString (Node(_,nil))="0" |

    toString (Node(1,x))=implode(invertlist(intltochl x)) |

    toString (Node(~1,x))=implode((#"~")::(invertlist(intltochl x)));



fun >> (Node(x),Node(y))=let

	val signx= #1(x);

	val signy= #1(y);

	val lstx= #2(x);

	val lsty= #2(y)

	in

	if signx=1 then if signy= ~1 then true else isBigger(lstx,lsty) 

		else if signy=1 then false else not(isBigger(lstx,lsty))

	end;



fun <<= (x,y)=not(>> (x,y));



fun == (Node(x),Node(y))=if #1(x) <> #1(y) then false else if #2(x)= #2(y) then true else false;



fun != (x,y)=not(== (x,y));



fun << (x,y)=(<<= (x,y)) andalso (!= (x,y)); 



fun >>= (x,y)=not(<< (x,y));



fun ++ (Node(x),Node(y))=let

	val signx= #1(x);

	val signy= #1(y);

	val lstx= #2(x);

	val lsty= #2(y)

	in

	if signx=1 andalso signy=1 then Node(1,Topla(lstx,lsty,0))

	else if signx= ~1 andalso signy= ~1 then Node(~1,Topla(lstx,lsty,0))

	else if signx=1 andalso signy= ~1 

		then if  >>= (Node(absval(x)),Node(absval(y))) then Node(1,delheadzeros(Cikar(lstx,lsty,0)))

						else Node(~1,delheadzeros(Cikar(lsty,lstx,0)))

	else  if  >>= (Node(absval(y)),Node(absval(x))) then Node(1,delheadzeros(Cikar(lsty,lstx,0)))

						else Node(~1,delheadzeros(Cikar(lstx,lsty,0)))

	end;



fun -- (Node(x),Node(y))= ++ (Node(x),Node( #1(y) * ~1, #2(y)));



fun ** (Node(x),Node(y))=let

	val signx= #1(x);

	val signy= #1(y);

	val lstx= #2(x);

	val lsty= #2(y)

	in

	Node(signx * signy,delheadzeros(Carp(lstx,lsty,0)))

	end;



fun // (Node(x),Node(y))=let

	val signx= #1(x);

	val signy= #1(y);

	val lstx= #2(x);

	val lsty= #2(y)

	in

	if lsty=nil then raise DivisionbyZero 

		else Node(signx*signy,delheadzeros(invertlist(Bol(signx*signy,lstx,lsty,getUstSinir(lstx,lsty,0)))))

	end;



fun %% (Node(x),Node(y))=let

	val signx= #1(x);

	val signy= #1(y);

	val lstx= #2(x);

	val lsty= #2(y)

	in

	if lsty=nil then raise DivisionbyZero 

	else -- (Node(x),** (Node(y),//(Node(x),Node(y)))) 

	end;



infix 9 //;

infix 9 %%;

infix 9 **;

infix 1 >>;

infix 1 <<=;

infix 1 ==;

infix 1 !=;

infix 1 <<;

infix 1 >>=;

infix 8 ++;	

infix 8 --;

end

end;