diff --git a/lib/assets/libs/long_int.js b/lib/assets/libs/long_int.js
new file mode 100644
--- /dev/null
+++ b/lib/assets/libs/long_int.js
@@ -0,0 +1,639 @@
+/*
+Module to manipulate long integers
+*/
+
+var $module=(function($B){
+
+eval($B.InjectBuiltins())
+
+var $LongIntDict = {__class__:$B.$type,__name__:'LongInt'}
+
+function add_pos(v1, v2){
+    // Add two positive numbers
+    // v1, v2 : strings
+    // Return an instance of LongInt
+
+    var res = '', carry = 0, iself=v1.length, sv=0
+    for(var i=v2.length-1;i>=0;i--){
+        iself--
+        if(iself<0){sv=0}else{sv=parseInt(v1.charAt(iself))}
+        x = (carry+sv+parseInt(v2.charAt(i))).toString()
+        if(x.length==2){res=x.charAt(1)+res;carry=parseInt(x.charAt(0))}
+        else{res=x+res;carry=0}
+    }
+    while(iself>0){
+        iself--
+        x = (carry+parseInt(v1.charAt(iself))).toString()
+        if(x.length==2){res=x.charAt(1)+res;carry=parseInt(x.charAt(0))}
+        else{res=x+res;carry=0}
+    }
+    if(carry){res=carry+res}        
+    return {__class__:$LongIntDict, value:res, pos:true}
+}
+
+function check_shift(shift){
+    // Check the argument of >> and <<
+    if(!isinstance(shift, LongInt)){
+        throw TypeError("shift must be LongInt, not '"+
+            $B.get_class(shift).__name__+"'")
+    }
+    if(!shift.pos){throw ValueError("negative shift count")}
+}
+
+function clone(obj){
+    // Used for traces
+    var obj1 = {}
+    for(var attr in obj){obj1[attr]=obj[attr]}
+    return obj1
+}
+
+function comp_pos(v1, v2){
+    // Compare two positive numbers
+    if(v1.length>v2.length){return 1}
+    else if(v1.length<v2.length){return -1}
+    else{
+        if(v1>v2){return 1}
+        else if(v1<v2){return -1}
+    }
+    return 0
+}
+
+function divmod_pos(v1, v2){
+    // v1, v2 : strings, represent 2 positive integers A and B
+    // Return [a, b] where a and b are instances of LongInt
+    // a = A // B, b = A % B
+    var v1_init = v1, quotient, mod
+    if(comp_pos(v1, v2)==-1){ // a < b
+        quotient='0'
+        mod = LongInt(v1)
+    }else if(v2==v1){ // a = b
+        quotient = '1';
+        mod = LongInt('0')
+    }else{
+        var quotient = '', v1_init = v1
+        var left = v1.substr(0, v2.length)
+        if(v1<v2){left = v1.substr(0, v2.length+1)}
+        var right = v1.substr(left.length)
+        // mv2 maps integers i from 2 to 9 to i*v2, used as a cache to avoid
+        // having to compute i*v2 each time
+        var mv2 = {}
+        // Javascript "safe integer" with the 15 first digits in v2,
+        // used in the algorithm to test candidate values
+        var jsv2 = parseInt(v2.substr(0,15))
+
+        // Division algorithm
+        // At each step in the division, v1 is split into substrings
+        // "left" is the left part, with the same length as v2
+        // "rest" is the rest of v1 after "left"
+        // The algorithm finds the one-digit integer "candidate" such
+        // that 0 <= left - candidate*v2 < v2
+        // It stops when right is empty
+        while(true){
+            // Uses JS division to test an approximate result
+            var jsleft = parseInt(left.substr(0,15))
+            var candidate = Math.floor(jsleft/jsv2).toString()
+
+            // Check that candidate is the correct result
+            // Start by computing candidate*v2 : for this, use the table
+            // mv2, which stores the multiples of v2 already calculated
+            if(mv2[candidate]===undefined){
+                mv2[candidate] = mul_pos(v2, candidate).value
+            }
+            if(comp_pos(left, mv2[candidate])==-1){
+                // If left < candidate * v2, use candidate-1
+                candidate--
+                if(mv2[candidate]===undefined){
+                    mv2[candidate] = mul_pos(v2, candidate).value
+                }
+            }
+
+            // Add candidate to the quotient
+            quotient += candidate
+
+            // New value for left : left - v2*candidate
+            left = sub_pos(left, mv2[candidate]).value
+
+            // Stop if all digits in v1 have been used
+            if(right.length==0){break}
+
+            // Else, add next digit to left and remove it from right
+            left += right.charAt(0)
+            right = right.substr(1)
+        }
+        // Modulo is A - (A//B)*B
+        mod = sub_pos(v1, mul_pos(quotient, v2).value)
+    }
+    return [LongInt(quotient), mod]
+}
+
+function mul_pos(v1, v2){
+    // Multiply positive numbers v1 by v2
+    // Make v2 smaller than v1
+    if(v1.length<v2.length){var a=v1; v1=v2 ; v2=a}
+    if(v2=='0'){return LongInt('0')}
+    var cols = {}, i=v2.length, j
+    
+    // Built the object "cols", indexed by integers from 1 to nb1+nb2-2
+    // where nb1 and nb2 are the number of digits in v1 and v2.
+    // cols[n] is the sum of v1[i]*v2[j] for i+j = n
+    
+    while(i--){
+        var car = v2.charAt(i)
+        if(car=="0"){
+            j = v1.length
+            while(j--){
+                if(cols[i+j]===undefined){cols[i+j]=0}
+            }        
+        }else if(car=="1"){
+            j = v1.length
+            while(j--){
+                var z = parseInt(v1.charAt(j))
+                if(cols[i+j]===undefined){cols[i+j]=z}
+                else{cols[i+j] += z}
+            }
+        }else{
+            var x = parseInt(car), j = v1.length, y, z
+            while(j--){
+                y = x * parseInt(v1.charAt(j))
+                if(cols[i+j]===undefined){cols[i+j]=y}
+                else{cols[i+j] += y}
+            }
+        }
+    }
+
+    // Transform cols so that cols[x] is a one-digit integers
+    i = v1.length+v2.length-1
+    while(i--){
+        var col = cols[i].toString()
+        if(col.length>1){
+            // If the value in cols[i] has more than one digit, only keep the
+            // last one and report the others at the right index
+            // For instance if cols[i] = 123, keep 3 in cols[i], add 2 to
+            // cols[i-1] and 1 to cols[i-2]
+            cols[i] = parseInt(col.charAt(col.length-1))
+            j = col.length
+            while(j-->1){
+                var report = parseInt(col.charAt(j-1))
+                var pos = i-col.length+j
+                if(cols[pos]===undefined){cols[pos]=report}
+                else{cols[pos] += report}
+            }
+        }
+    }
+
+    // Find minimum index in cols
+    // The previous loop may have introduced negative indices
+    var imin
+    for(var attr in cols){
+        i = parseInt(attr)
+        if(imin===undefined){imin=i}
+        else if(i<imin){imin=i}
+    }
+
+    // Result is the concatenation of digits in cols
+    var res = ''
+    for(var i=imin;i<=v1.length+v2.length-2;i++){res+=cols[i].toString()}
+    return LongInt(res)
+}
+
+function sub_pos(v1, v2){
+    // Substraction of positive numbers with v1>=v2
+
+    var res = '', carry = 0, i1=v1.length, sv=0
+    
+    // For all digits in v2, starting by the rightmost, substract it from
+    // the matching digit in v1
+    // This is the equivalent of the manual operation :
+    //    12345678
+    //   -   98765
+    //
+    // We begin by the rightmost operation : 8-5 (3, no carry),
+    // then 7-6 (1, no carry)
+    // then 6-7 (9, carry 1) and so on
+    for(var i=v2.length-1;i>=0;i--){
+        i1--
+        sv = parseInt(v1.charAt(i1))
+        x = (sv-carry-parseInt(v2.charAt(i)))
+        if(x<0){res=(10+x)+res;carry=1}
+        else{res=x+res;carry=0}
+    }
+    
+    // If there are remaining digits in v1, substract the carry, if any
+    while(i1>0){
+        i1--
+        x = (parseInt(v1.charAt(i1))-carry)
+        if(x<0){res=(10+x)+res;carry=1}
+        else{res=x+res;carry=0}
+    }
+
+    // Remove leading zeros and return the result
+    while(res.charAt(0)=='0' && res.length>1){res=res.substr(1)}
+    return {__class__:$LongIntDict, value:res, pos:true}
+}
+
+// Special methods to implement operations on instances of LongInt
+
+$LongIntDict.__abs__ = function(self){
+    return {__class__:$LongIntDict, value: self.value, pos:true}
+}
+
+$LongIntDict.__add__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    // Addition of "self" and "other"
+    // If both have the same sign (+ or -) we add their absolute values
+    // If they have different sign we use the substraction of their
+    // absolute values
+    var res
+    if(self.pos&&other.pos){  // self > 0, other > 0
+        return add_pos(self.value, other.value)
+    }else if(!self.pos&&!other.pos){ // self < 0, other < 0
+        res = add_pos(self.value, other.value)
+        res.pos = false
+        return res
+    }else if(self.pos && !other.pos){ // self > 0, other < 0
+        switch (comp_pos(self.value, other.value)){
+            case 1:
+                res = sub_pos(self.value, other.value)
+                break
+            case 0:
+                res = {__class__:$LongIntDict, value:0, pos:true}
+                break
+            case -1:
+                res = sub_pos(other.value, self.value)
+                res.pos = false
+                break
+        }
+        return res
+    }else{ // self < 0, other > 0
+        switch(comp_pos(self.value, other.value)){
+            case 1:
+                res = sub_pos(self.value, other.value)
+                res.pos = false
+                break
+            case 0:
+                res = {__class__:$LongIntDict, value:0, pos:true}
+                break
+            case -1:
+                res = sub_pos(other.value, self.value)
+                break
+        }
+        return res
+    }
+}
+
+$LongIntDict.__and__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    // Bitwise "and" : build the binary representation of self and other
+    var v1 = $LongIntDict.__index__(self)
+    var v2 = $LongIntDict.__index__(other)
+    // apply "and" on zeros and ones
+    if(v1.length<v2.length){var temp=v2;v2=v1;v1=temp}
+    var start = v1.length-v2.length
+    var res = ''
+    for(var i=0;i<v2.length;i++){
+        if(v1.charAt(start+i)=='1' && v2.charAt(i)=='1'){res += '1'}
+        else{res += '0'}
+    }
+    // Return the LongInt instance represented by res in base 2
+    return LongInt(res, 2)
+}
+
+$LongIntDict.__divmod__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+
+    var dm = divmod_pos(self.value, other.value)
+    if(self.pos!==other.pos){
+        if(dm[0].value!='0'){dm[0].pos = false}
+        if(dm[1].value!='0'){
+            // If self and other have different signs and self is not a multiple
+            // of other, round to the previous integer
+            dm[0] = $LongIntDict.__sub__(dm[0], LongInt('1'))
+            dm[1] = $LongIntDict.__add__(dm[1], LongInt('1'))
+        }
+    }
+    return dm    
+}
+
+$LongIntDict.__eq__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    return self.value==other.value && self.pos==other.pos
+}
+
+$LongIntDict.__floordiv__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    return $LongIntDict.__divmod__(self, other)[0]
+}
+
+$LongIntDict.__ge__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    if(self.value.length>other.value.length){return true}
+    else if(self.value.length<other.value.length){return false}
+    else{return self.value >= other.value}
+}
+
+$LongIntDict.__gt__ = function(self, other){
+    return !$LongIntDict.__le__(self, other)
+}
+
+$LongIntDict.__index__ = function(self){
+    // Used by bin()
+    // returns a string with the binary value of self
+    // The algorithm computes the result of the floor division of self by 2
+    
+    // XXX to do : negative integers
+    
+    var res = '', pos=self.value.length,
+        temp = self.value, d
+    while(true){
+        d = divmod_pos(temp, '2')
+        res = d[1].value + res
+        temp = d[0].value
+        if(temp=='0'){break}
+    }
+    return res
+}
+
+$LongIntDict.__invert__ = function(self){
+    var bin = $LongIntDict.__index__(self)
+    var res = ''
+    for(var i=0;i<bin.length;i++){
+        res += bin.charAt(i)=='0' ? '1' : '0'
+    }
+    return LongInt(res, 2)
+}
+
+$LongIntDict.__le__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    if(self.value.length>other.value.length){return false}
+    else if(self.value.length<other.value.length){return true}
+    else{return self.value <= other.value}
+}
+
+$LongIntDict.__lt__ = function(self, other){
+    return !$LongIntDict.__ge__(self, other)
+}
+
+$LongIntDict.__lshift__ = function(self, shift){
+    check_shift(shift)
+    var res = self.value
+    while(true){
+        var x, carry=0, res1=''
+        for(var i=res.length-1;i>=0;i--){
+            x = (carry+parseInt(res.charAt(i))*2).toString()
+            if(x.length==2){res1=x.charAt(1)+res1;carry=parseInt(x.charAt(0))}
+            else{res1=x+res1;carry=0}
+        }
+        if(carry){res1=carry+res1}
+        res=res1
+        shift = sub_pos(shift.value, '1')
+        if(shift.value=='0'){break}
+    }
+    return {__class__:$LongIntDict, value:res, pos:self.pos}
+}
+
+$LongIntDict.__mod__ = function(self, other){
+    return $LongIntDict.__divmod__(self, other)[1]
+}
+
+$LongIntDict.__mro__ = [$LongIntDict, _b_.object.$dict]
+
+$LongIntDict.__mul__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    var res = mul_pos(self.value, other.value)
+    if(self.pos==other.pos){return res}
+    res.pos = false
+    return res
+}
+
+$LongIntDict.__neg__ = function(obj){
+    return {__class__:$LongIntDict, value:obj.value, pos:!obj.pos}
+}
+
+$LongIntDict.__or__ = function(self, other){
+    var v1 = $LongIntDict.__index__(self)
+    var v2 = $LongIntDict.__index__(other)
+    if(v1.length<v2.length){var temp=v2;v2=v1;v1=temp}
+    var start = v1.length-v2.length
+    var res = v1.substr(0, start)
+    for(var i=0;i<v2.length;i++){
+        if(v1.charAt(start+i)=='1' || v2.charAt(i)=='1'){res += '1'}
+        else{res += '0'}
+    }
+    return LongInt(res, 2)
+}
+
+
+$LongIntDict.__pow__ = function(self, power){
+    if (typeof power == "number") {
+        power=LongInt(_b_.str(power))
+    }else if(!isinstance(power, LongInt)){
+        var msg = "power must be a LongDict, not '"
+        throw TypeError(msg+$B.get_class(power).__name__+"'")
+    }
+    if(!power.pos){
+        if(self.value=='1'){return self}
+        // For all other integers, x**-n is 0
+        return LongInt('0')
+    }else if(power.value=='0'){
+        return LongInt('1')
+    }
+    var res = {__class__:$LongIntDict, value:self.value, pos:self.pos}
+    var pow = power.value
+    while(true){
+        pow = sub_pos(pow, '1').value
+        if(pow == '0'){break}
+        res = $LongIntDict.__mul__(res, self)
+    }
+    return res    
+}
+
+$LongIntDict.__rshift__ = function(self, shift){
+    check_shift(shift)
+    var res = self.value
+    while(true){
+        res = divmod_pos(res, '2')[0].value
+        if(res.value=='0'){break}
+        shift = sub_pos(shift.value, '1')
+        if(shift.value=='0'){break}
+    }
+    return {__class__:$LongIntDict, value:res, pos:self.pos}
+}
+
+$LongIntDict.__str__ = $LongIntDict.__repr__ = function(self){
+    var res = "LongInt('"
+    if(!self.pos){res += '-'}
+    return res+self.value+"')"
+}
+
+$LongIntDict.__sub__ = function(self, other){
+    if (typeof other == 'number') other=LongInt(_b_.str(other))
+    var res
+    if(self.pos && other.pos){
+        switch(comp_pos(self.value, other.value)){
+            case 1:
+                res = sub_pos(self.value, other.value)
+                break
+            case 0:
+                res = {__class__:$LongIntDict, value:'0', pos:true}
+                break
+            case -1:
+                res = sub_pos(other.value, self.value)
+                res.pos = false
+                break
+        }
+        return res
+    }else if(!self.pos && !other.pos){
+        switch(comp_pos(self.value, other.value)){
+            case 1:
+                res = sub_pos(self.value, other.value)
+                res.pos = false
+                break
+            case 0:
+                res = {__class__:$LongIntDict, value:'0', pos:true}
+                break
+            case -1:
+                res = sub_pos(other.value, self.value)
+                break
+        }
+        return res
+    }else if(self.pos && !other.pos){
+        return add_pos(self.value, other.value)
+    }else{
+        res = add_pos(self.value, other.value)
+        res.pos = false
+        return res
+    }
+}
+
+$LongIntDict.__xor__ = function(self, other){
+    var v1 = $LongIntDict.__index__(self)
+    var v2 = $LongIntDict.__index__(other)
+    if(v1.length<v2.length){var temp=v2;v2=v1;v1=temp}
+    var start = v1.length-v2.length
+    var res = v1.substr(0, start)
+    for(var i=0;i<v2.length;i++){
+        if(v1.charAt(start+i)=='1' && v2.charAt(i)=='0'){res += '1'}
+        else if(v1.charAt(start+i)=='0' && v2.charAt(i)=='1'){res += '1'}
+        else{res += '0'}
+    }
+    return LongInt(res, 2)
+}
+
+$LongIntDict.to_base = function(self, base){
+    // Returns the string representation of self in specified base
+    var res='', v=self.value
+    while(v>0){
+        var dm = divmod_pos(v, base.toString())
+        res = parseInt(dm[1].value).toString(base)+res
+        v = dm[0].value
+        if(v==0){break}
+    }
+    return res
+}
+
+function digits(base){
+    // Return an object where keys are all the digits valid in specified base
+    // and value is "true"
+    // Used to test if the string passed as first argument to LongInt is valid
+    var is_digits = {}
+    // Number from 0 to base, or from 0 to 9 if base > 10
+    for(var i=0;i<base;i++){
+        if(i==10){break}
+        is_digits[i]=true
+    }
+    if(base>10){
+        // Additional letters
+        // For instance in base 16, add "abcdefABCDEF" as keys
+        for(var i=0;i<base-10;i++){
+            is_digits[String.fromCharCode(65+i)]=true
+            is_digits[String.fromCharCode(97+i)]=true
+        }
+    }
+    return is_digits
+}
+
+var MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
+var MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;
+
+function isSafeInteger(n) {
+    return (typeof n === 'number' &&
+        Math.round(n) === n &&
+        Number.MIN_SAFE_INTEGER <= n &&
+        n <= Number.MAX_SAFE_INTEGER);
+}
+
+function LongInt(value, base){
+    if(arguments.length>2){
+        throw _b_.TypeError("LongInt takes at most 2 arguments ("+
+            arguments.length+" given)")
+    }
+    // base defaults to 10
+    if(base===undefined){base = 10}
+    else if(!isinstance(base, int)){
+        throw TypeError("'"+$B.get_class(base).__name__+"' object cannot be interpreted as an integer")
+    }
+    if(base<0 || base==1 || base>36){
+        throw ValueError("LongInt() base must be >= 2 and <= 36")
+    }
+    if(isinstance(value, float)){
+        if(value>=0){value=Math.round(value.value)}
+        else{value=Math.ceil(value.value)}
+    }
+    if(typeof value=='number'){
+        if(isSafeInteger(value)){value = value.toString()}
+        else{throw ValueError("argument of long_int is not a safe integer")}
+    }else if(typeof value!='string'){
+        throw ValueError("argument of long_int must be a string, not "+
+            $B.get_class(value).__name__)
+    }
+    var has_prefix = false, pos = true, start = 0
+    // Strip leading and trailing whitespaces
+    while(value.charAt(0)==' ' && value.length){value = value.substr(1)}
+    while(value.charAt(value.length-1)==' ' && value.length){
+        value = value.substr(0, value.length-1)
+    }
+    // Check if string starts with + or -
+    if(value.charAt(0)=='+'){has_prefix=true}
+    else if(value.charAt(0)=='-'){has_prefix=true;pos=false}
+    if(has_prefix){
+        // Remove prefix
+        if(value.length==1){
+            // "+" or "-" alone are not valid arguments
+            throw ValueError('LongInt argument is not a valid number: "'+value+'"')
+        }else{value=value.substr(1)}
+    }
+    // Ignore leading zeros
+    while(start<value.length-1 && value.charAt(start)=='0'){start++}
+    value = value.substr(start)
+
+    // Check if all characters in value are valid in the base
+    var is_digits = digits(base), point = -1
+    for(var i=0;i<value.length;i++){
+        if(value.charAt(i)=='.' && point==-1){point=i}
+        else if(!is_digits[value.charAt(i)]){
+            throw ValueError('LongInt argument is not a valid number: "'+value+'"')
+        }
+    }
+    if(point!=-1){value=value.substr(0,point)}
+    if(base!=10){
+        // Conversion to base 10
+        var coef = '1', v10 = LongInt(0),
+            pos = value.length, digit_base10
+        while(pos--){
+            digit_base10 = parseInt(value.charAt(pos), base).toString()
+            digit_by_coef = mul_pos(coef, digit_base10).value
+            v10 = add_pos(v10.value, digit_by_coef)
+            coef = mul_pos(coef, base.toString()).value
+        }
+        return v10
+    }
+    return {__class__:$LongIntDict, value:value, pos:pos}
+}
+
+LongInt.__class__ = $B.$factory
+LongInt.$dict = $LongIntDict
+$LongIntDict.$factory = LongInt
+
+return {LongInt:LongInt}
+
+})(__BRYTHON__)