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