@@ -0,0 +1,394 @@
1+/*
2+ BigInteger Javascript code taken from:
3+ https://github.com/peterolson
4+*/
5+
6+var __IDR__;
7+(function(__IDR__) {
8+ /** @constructor */
9+ __IDR__.Type = function(type) {
10+ this.type = type;
11+ };
12+
13+ __IDR__.Int = new __IDR__.Type('Int');
14+ __IDR__.Char = new __IDR__.Type('Char');
15+ __IDR__.String = new __IDR__.Type('String');
16+ __IDR__.Integer = new __IDR__.Type('Integer');
17+ __IDR__.Float = new __IDR__.Type('Float');
18+ __IDR__.Forgot = new __IDR__.Type('Forgot');
19+
20+
21+ /** @constructor */
22+ __IDR__.Tailcall = function(f) { this.f = f };
23+
24+ /** @constructor */
25+ __IDR__.Con = function(i,name,vars) {
26+ this.i = i;
27+ this.name = name;
28+ this.vars = vars;
29+ };
30+
31+ __IDR__.tailcall = function(f) {
32+ var __f = f;
33+ var ret;
34+ while (__f) {
35+ f = __f;
36+ __f = null;
37+ ret = f();
38+
39+ if (ret instanceof __IDR__.Tailcall) {
40+ __f = ret.f;
41+ } else {
42+ return ret;
43+ }
44+ }
45+ };
46+
47+ __IDR__.print = function(s){
48+ var m = s.match(/(.*)\n$/);
49+ console.log(m ? m[1] : s);
50+ };
51+
52+ __IDR__.bigInt = (function () {
53+ var base = 10000000, logBase = 7;
54+ var sign = {
55+ positive: false,
56+ negative: true
57+ };
58+
59+ var normalize = function (first, second) {
60+ var a = first.value, b = second.value;
61+ var length = a.length > b.length ? a.length : b.length;
62+ for (var i = 0; i < length; i++) {
63+ a[i] = a[i] || 0;
64+ b[i] = b[i] || 0;
65+ }
66+ for (var i = length - 1; i >= 0; i--) {
67+ if (a[i] === 0 && b[i] === 0) {
68+ a.pop();
69+ b.pop();
70+ } else break;
71+ }
72+ if (!a.length) a = [0], b = [0];
73+ first.value = a;
74+ second.value = b;
75+ };
76+
77+ var parse = function (text, first) {
78+ if (typeof text === "object") return text;
79+ text += "";
80+ var s = sign.positive, value = [];
81+ if (text[0] === "-") {
82+ s = sign.negative;
83+ text = text.slice(1);
84+ }
85+ var text = text.split("e");
86+ if (text.length > 2) throw new Error("Invalid integer");
87+ if (text[1]) {
88+ var exp = text[1];
89+ if (exp[0] === "+") exp = exp.slice(1);
90+ exp = parse(exp);
91+ if (exp.lesser(0)) throw new Error("Cannot include negative exponent part for integers");
92+ while (exp.notEquals(0)) {
93+ text[0] += "0";
94+ exp = exp.prev();
95+ }
96+ }
97+ text = text[0];
98+ if (text === "-0") text = "0";
99+ var isValid = /^([0-9][0-9]*)$/.test(text);
100+ if (!isValid) throw new Error("Invalid integer");
101+ while (text.length) {
102+ var divider = text.length > logBase ? text.length - logBase : 0;
103+ value.push(+text.slice(divider));
104+ text = text.slice(0, divider);
105+ }
106+ var val = bigInt(value, s);
107+ if (first) normalize(first, val);
108+ return val;
109+ };
110+
111+ var goesInto = function (a, b) {
112+ var a = bigInt(a, sign.positive), b = bigInt(b, sign.positive);
113+ if (a.equals(0)) throw new Error("Cannot divide by 0");
114+ var n = 0;
115+ do {
116+ var inc = 1;
117+ var c = bigInt(a.value, sign.positive), t = c.times(10);
118+ while (t.lesser(b)) {
119+ c = t;
120+ inc *= 10;
121+ t = t.times(10);
122+ }
123+ while (c.lesserOrEquals(b)) {
124+ b = b.minus(c);
125+ n += inc;
126+ }
127+ } while (a.lesserOrEquals(b));
128+
129+ return {
130+ remainder: b.value,
131+ result: n
132+ };
133+ };
134+
135+ var bigInt = function (value, s) {
136+ var self = {
137+ value: value,
138+ sign: s
139+ };
140+ var o = {
141+ value: value,
142+ sign: s,
143+ negate: function (m) {
144+ var first = m || self;
145+ return bigInt(first.value, !first.sign);
146+ },
147+ abs: function (m) {
148+ var first = m || self;
149+ return bigInt(first.value, sign.positive);
150+ },
151+ add: function (n, m) {
152+ var s, first = self, second;
153+ if (m) (first = parse(n)) && (second = parse(m));
154+ else second = parse(n, first);
155+ s = first.sign;
156+ if (first.sign !== second.sign) {
157+ first = bigInt(first.value, sign.positive);
158+ second = bigInt(second.value, sign.positive);
159+ return s === sign.positive ?
160+ o.subtract(first, second) :
161+ o.subtract(second, first);
162+ }
163+ normalize(first, second);
164+ var a = first.value, b = second.value;
165+ var result = [],
166+ carry = 0;
167+ for (var i = 0; i < a.length || carry > 0; i++) {
168+ var sum = (a[i] || 0) + (b[i] || 0) + carry;
169+ carry = sum >= base ? 1 : 0;
170+ sum -= carry * base;
171+ result.push(sum);
172+ }
173+ return bigInt(result, s);
174+ },
175+ plus: function (n, m) {
176+ return o.add(n, m);
177+ },
178+ subtract: function (n, m) {
179+ var first = self, second;
180+ if (m) (first = parse(n)) && (second = parse(m));
181+ else second = parse(n, first);
182+ if (first.sign !== second.sign) return o.add(first, o.negate(second));
183+ if (first.sign === sign.negative) return o.subtract(o.negate(second), o.negate(first));
184+ if (o.compare(first, second) === -1) return o.negate(o.subtract(second, first));
185+ var a = first.value, b = second.value;
186+ var result = [],
187+ borrow = 0;
188+ for (var i = 0; i < a.length; i++) {
189+ a[i] -= borrow;
190+ borrow = a[i] < b[i] ? 1 : 0;
191+ var minuend = (borrow * base) + a[i] - b[i];
192+ result.push(minuend);
193+ }
194+ return bigInt(result, sign.positive);
195+ },
196+ minus: function (n, m) {
197+ return o.subtract(n, m);
198+ },
199+ multiply: function (n, m) {
200+ var s, first = self, second;
201+ if (m) (first = parse(n)) && (second = parse(m));
202+ else second = parse(n, first);
203+ s = first.sign !== second.sign;
204+ var a = first.value, b = second.value;
205+ var resultSum = [];
206+ for (var i = 0; i < a.length; i++) {
207+ resultSum[i] = [];
208+ var j = i;
209+ while (j--) {
210+ resultSum[i].push(0);
211+ }
212+ }
213+ var carry = 0;
214+ for (var i = 0; i < a.length; i++) {
215+ var x = a[i];
216+ for (var j = 0; j < b.length || carry > 0; j++) {
217+ var y = b[j];
218+ var product = y ? (x * y) + carry : carry;
219+ carry = product > base ? Math.floor(product / base) : 0;
220+ product -= carry * base;
221+ resultSum[i].push(product);
222+ }
223+ }
224+ var max = -1;
225+ for (var i = 0; i < resultSum.length; i++) {
226+ var len = resultSum[i].length;
227+ if (len > max) max = len;
228+ }
229+ var result = [], carry = 0;
230+ for (var i = 0; i < max || carry > 0; i++) {
231+ var sum = carry;
232+ for (var j = 0; j < resultSum.length; j++) {
233+ sum += resultSum[j][i] || 0;
234+ }
235+ carry = sum > base ? Math.floor(sum / base) : 0;
236+ sum -= carry * base;
237+ result.push(sum);
238+ }
239+ return bigInt(result, s);
240+ },
241+ times: function (n, m) {
242+ return o.multiply(n, m);
243+ },
244+ divmod: function (n, m) {
245+ var s, first = self, second;
246+ if (m) (first = parse(n)) && (second = parse(m));
247+ else second = parse(n, first);
248+ s = first.sign !== second.sign;
249+ if (bigInt(first.value, first.sign).equals(0)) return {
250+ quotient: bigInt([0], sign.positive),
251+ remainder: bigInt([0], sign.positive)
252+ };
253+ if (second.equals(0)) throw new Error("Cannot divide by zero");
254+ var a = first.value, b = second.value;
255+ var result = [], remainder = [];
256+ for (var i = a.length - 1; i >= 0; i--) {
257+ var n = [a[i]].concat(remainder);
258+ var quotient = goesInto(b, n);
259+ result.push(quotient.result);
260+ remainder = quotient.remainder;
261+ }
262+ result.reverse();
263+ return {
264+ quotient: bigInt(result, s),
265+ remainder: bigInt(remainder, first.sign)
266+ };
267+ },
268+ divide: function (n, m) {
269+ return o.divmod(n, m).quotient;
270+ },
271+ over: function (n, m) {
272+ return o.divide(n, m);
273+ },
274+ mod: function (n, m) {
275+ return o.divmod(n, m).remainder;
276+ },
277+ pow: function (n, m) {
278+ var first = self, second;
279+ if (m) (first = parse(n)) && (second = parse(m));
280+ else second = parse(n, first);
281+ var a = first, b = second;
282+ if (b.lesser(0)) return ZERO;
283+ if (b.equals(0)) return ONE;
284+ var result = bigInt(a.value, a.sign);
285+
286+ if (b.mod(2).equals(0)) {
287+ var c = result.pow(b.over(2));
288+ return c.times(c);
289+ } else {
290+ return result.times(result.pow(b.minus(1)));
291+ }
292+ },
293+ next: function (m) {
294+ var first = m || self;
295+ return o.add(first, 1);
296+ },
297+ prev: function (m) {
298+ var first = m || self;
299+ return o.subtract(first, 1);
300+ },
301+ compare: function (n, m) {
302+ var first = self, second;
303+ if (m) (first = parse(n)) && (second = parse(m, first));
304+ else second = parse(n, first);
305+ normalize(first, second);
306+ if (first.value.length === 1 && second.value.length === 1 && first.value[0] === 0 && second.value[0] === 0) return 0;
307+ if (second.sign !== first.sign) return first.sign === sign.positive ? 1 : -1;
308+ var multiplier = first.sign === sign.positive ? 1 : -1;
309+ var a = first.value, b = second.value;
310+ for (var i = a.length - 1; i >= 0; i--) {
311+ if (a[i] > b[i]) return 1 * multiplier;
312+ if (b[i] > a[i]) return -1 * multiplier;
313+ }
314+ return 0;
315+ },
316+ compareAbs: function (n, m) {
317+ var first = self, second;
318+ if (m) (first = parse(n)) && (second = parse(m, first));
319+ else second = parse(n, first);
320+ first.sign = second.sign = sign.positive;
321+ return o.compare(first, second);
322+ },
323+ equals: function (n, m) {
324+ return o.compare(n, m) === 0;
325+ },
326+ notEquals: function (n, m) {
327+ return !o.equals(n, m);
328+ },
329+ lesser: function (n, m) {
330+ return o.compare(n, m) < 0;
331+ },
332+ greater: function (n, m) {
333+ return o.compare(n, m) > 0;
334+ },
335+ greaterOrEquals: function (n, m) {
336+ return o.compare(n, m) >= 0;
337+ },
338+ lesserOrEquals: function (n, m) {
339+ return o.compare(n, m) <= 0;
340+ },
341+ isPositive: function (m) {
342+ var first = m || self;
343+ return first.sign === sign.positive;
344+ },
345+ isNegative: function (m) {
346+ var first = m || self;
347+ return first.sign === sign.negative;
348+ },
349+ isEven: function (m) {
350+ var first = m || self;
351+ return first.value[0] % 2 === 0;
352+ },
353+ isOdd: function (m) {
354+ var first = m || self;
355+ return first.value[0] % 2 === 1;
356+ },
357+ toString: function (m) {
358+ var first = m || self;
359+ var str = "", len = first.value.length;
360+ while (len--) {
361+ str += (base.toString() + first.value[len]).slice(-logBase);
362+ }
363+ while (str[0] === "0") {
364+ str = str.slice(1);
365+ }
366+ if (!str.length) str = "0";
367+ var s = first.sign === sign.positive ? "" : "-";
368+ return s + str;
369+ },
370+ toJSNumber: function (m) {
371+ return +o.toString(m);
372+ },
373+ valueOf: function (m) {
374+ return o.toJSNumber(m);
375+ }
376+ };
377+ return o;
378+ };
379+
380+ var ZERO = bigInt([0], sign.positive);
381+ var ONE = bigInt([1], sign.positive);
382+ var MINUS_ONE = bigInt([1], sign.negative);
383+
384+ var fnReturn = function (a) {
385+ if (typeof a === "undefined") return ZERO;
386+ return parse(a);
387+ };
388+ fnReturn.zero = ZERO;
389+ fnReturn.one = ONE;
390+ fnReturn.minusOne = MINUS_ONE;
391+ return fnReturn;
392+ })();
393+})(__IDR__ || (__IDR__ = {}));
394+