@magic-xpa/gui 4.1100.0-dev4110.24 → 4.1100.0-dev4110.241

package/esm2022/src/management/data/NUM_TYPE.mjs

@@ -0,0 +1,1739 @@
+import { Int32, NNumber, NString, NumberStyles, StringBuilder } from '@magic-xpa/mscorelib';
+import { Constants, PICInterface, Randomizer, StorageAttribute, UtilStrByteMode } from '@magic-xpa/utils';
+import { PIC } from '../gui/PIC';
+import { Events } from '../../Events';
+import { GuiEnvironment } from '../../GuiEnvironment';
+export class NUM_TYPE {
+    static INT_ZERO_HEX = "00000000";
+    static NO_ROOM = -1;
+    static ZERO_FILL = -2;
+    static NUM_SIZE = 20;
+    static NUM_LONG_TYPE = -1;
+    static EXP_BIAS = 64;
+    static SIGN_MASK = -128;
+    COMMACHAR = ',';
+    DECIMALCHAR = '.';
+    SIGNIFICANT_NUM_SIZE = 0;
+    _data = new Int8Array(NUM_TYPE.NUM_SIZE);
+    set Data(value) {
+        this._data = value;
+    }
+    get Data() {
+        return this._data;
+    }
+    constructor(recordHexStrOrByteValOrDecStrOrNumFrom, offsetOrPic, lengthOrCompIdx) {
+        if (arguments.length === 0) {
+            this.constructor_0();
+            return;
+        }
+        if (arguments.length === 1 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom.constructor === String)) {
+            this.constructor_1(recordHexStrOrByteValOrDecStrOrNumFrom);
+            return;
+        }
+        if (arguments.length === 3 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom instanceof Int8Array) && (offsetOrPic === null || offsetOrPic.constructor === Number) && (lengthOrCompIdx === null || lengthOrCompIdx.constructor === Number)) {
+            this.constructor_2(recordHexStrOrByteValOrDecStrOrNumFrom, offsetOrPic, lengthOrCompIdx);
+            return;
+        }
+        if (arguments.length === 1 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom instanceof Int8Array)) {
+            this.constructor_3(recordHexStrOrByteValOrDecStrOrNumFrom);
+            return;
+        }
+        if (arguments.length === 3 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom.constructor === String) && (offsetOrPic === null || offsetOrPic instanceof PIC) && (lengthOrCompIdx === null || lengthOrCompIdx.constructor === Number)) {
+            this.constructor_4(recordHexStrOrByteValOrDecStrOrNumFrom, offsetOrPic, lengthOrCompIdx);
+            return;
+        }
+        this.constructor_5(recordHexStrOrByteValOrDecStrOrNumFrom);
+    }
+    constructor_0() {
+        this.initConst();
+        this.NUM_ZERO();
+    }
+    constructor_1(recordHexStr) {
+        let i = 0;
+        let twoDigits;
+        this.initConst();
+        try {
+            for (i = 0; i < this.SIGNIFICANT_NUM_SIZE; i = i + 1) {
+                twoDigits = recordHexStr.substr(i * 2, 2);
+                this._data[i] = NUM_TYPE.toSByte(NNumber.Parse(twoDigits, NumberStyles.HexNumber));
+            }
+        }
+        catch (ex) {
+            Events.WriteWarningToLog(ex);
+            this.NUM_ZERO();
+        }
+    }
+    constructor_2(byteVal, offset, length) {
+        this.constructor_0();
+        for (let i = 0; i < length; i = i + 1) {
+            this._data[i] = byteVal[i + offset];
+        }
+    }
+    constructor_3(byteVal) {
+        this.constructor_2(byteVal, 0, byteVal.length);
+    }
+    constructor_4(decStr, pic, compIdx) {
+        this.constructor_0();
+        this.from_a(decStr, pic, compIdx);
+    }
+    constructor_5(numFrom) {
+        this.initConst();
+        this._data = new Int8Array(numFrom._data.length);
+        for (let _ai = 0; _ai < this._data.length; ++_ai)
+            this._data[_ai] = numFrom._data[_ai];
+    }
+    toDisplayValue(pic) {
+        return this.to_a(pic);
+    }
+    initConst() {
+        let env = GuiEnvironment.Environment;
+        this.DECIMALCHAR = env.GetDecimal();
+        this.COMMACHAR = env.GetThousands();
+        this.SIGNIFICANT_NUM_SIZE = env.GetSignificantNumSize();
+    }
+    toXMLrecord() {
+        let hexStr = new StringBuilder(this.SIGNIFICANT_NUM_SIZE * 2);
+        let num;
+        if (this.NUM_IS_LONG())
+            num = 5;
+        else
+            num = this.SIGNIFICANT_NUM_SIZE;
+        for (let i = 0; i < this.SIGNIFICANT_NUM_SIZE; i++) {
+            if (i < num)
+                hexStr.Append(('0' + (this._data[i] & 0xFF).toString(16)).slice(-2));
+            else
+                hexStr.Append("00");
+        }
+        return hexStr.ToString().toUpperCase();
+    }
+    from_a(Alpha, pic, compIdx) {
+        let i;
+        let idx;
+        let dec;
+        let decs;
+        let digit;
+        let len;
+        let no_pic;
+        let Pos;
+        let SType;
+        let SPart;
+        let Signed;
+        let buf;
+        let mask = "";
+        let c;
+        let NgtvPrmt;
+        let Scan = "";
+        let Pbuf = "";
+        let is_negative;
+        let negStr;
+        let negPref;
+        let posPref;
+        let negSuff;
+        let posSuff;
+        let specialValNewPolicy = GuiEnvironment.Environment.GetSpecialValNewPolicy();
+        no_pic = (pic == null);
+        len = 0;
+        SType = false;
+        SPart = false;
+        if (!no_pic) {
+            mask = pic.getMask();
+            if (!specialValNewPolicy)
+                if (Alpha.length > pic.getMaskSize())
+                    Alpha = Alpha.substr(0, pic.getMaskSize());
+            NgtvPrmt = pic.isNegative();
+            if (NgtvPrmt) {
+                negPref = pic.getNegPref_();
+                posPref = pic.getPosPref_();
+                negSuff = pic.getNegSuff_();
+                posSuff = pic.getPosSuff_();
+                if (negPref.length === posPref.length) {
+                    if (negPref.length === 0 || negPref === posPref)
+                        SPart = false;
+                    else
+                        SPart = true;
+                }
+                else
+                    SPart = true;
+                if (SPart)
+                    negStr = negPref;
+                else
+                    negStr = negSuff;
+                if (negStr.length === 0)
+                    SType = true;
+                else
+                    SType = false;
+                if (SType)
+                    Scan = (SPart ? posPref : posSuff);
+                else
+                    Scan = (SPart ? negPref : negSuff);
+                len = Scan.length;
+            }
+        }
+        else {
+            pic = new PIC("", StorageAttribute.NUMERIC, compIdx);
+            NgtvPrmt = false;
+        }
+        dec = false;
+        decs = 0;
+        digit = 0;
+        Signed = 0;
+        for (idx = 0; idx < Alpha.length;) {
+            if (no_pic || (specialValNewPolicy && idx >= pic.getMaskSize()) || mask[idx] === String.fromCharCode(PICInterface.PIC_N)) {
+                c = Alpha[idx];
+                if (specialValNewPolicy) {
+                    if (dec && decs === pic.getDec()) {
+                        break;
+                    }
+                }
+                if (UtilStrByteMode.isDigit(c)) {
+                    digit++;
+                    Pbuf += c;
+                    if (dec)
+                        decs++;
+                }
+                else if (c === this.DECIMALCHAR) {
+                    Pbuf += this.DECIMALCHAR;
+                    dec = true;
+                }
+                else if (c !== this.COMMACHAR) {
+                    if (NgtvPrmt && Signed === 0) {
+                        Signed = 1;
+                        for (i = idx, Pos = 0; i <= Alpha.length && Pos < len; i++) {
+                            if (no_pic || mask[i] === String.fromCharCode(PICInterface.PIC_N)) {
+                                c = Alpha[i];
+                                if (c !== Scan[Pos]) {
+                                    if (c === '-' && !SType)
+                                        break;
+                                    if (c === '+' && SType)
+                                        break;
+                                    Signed = -1;
+                                    break;
+                                }
+                                Pos++;
+                            }
+                        }
+                        if (Pos > 0 && Pos < len)
+                            Signed = -1;
+                    }
+                    else {
+                        if (idx === 0) {
+                            if (pic.getNegPref_().length > 0)
+                                if (Alpha.startsWith(pic.getNegPref_())) {
+                                    idx += pic.getNegPref_().length;
+                                    continue;
+                                }
+                            if (pic.getPosPref_().length > 0)
+                                if (Alpha.startsWith(pic.getPosPref_())) {
+                                    idx += pic.getPosPref_().length;
+                                    continue;
+                                }
+                        }
+                        else {
+                            if (pic.getNegSuff_().length > 0)
+                                if (Alpha.endsWith(pic.getNegSuff_())) {
+                                    idx += pic.getNegSuff_().length;
+                                    continue;
+                                }
+                            if (pic.getPosSuff_().length > 0)
+                                if (Alpha.endsWith(pic.getPosSuff_())) {
+                                    idx += pic.getPosSuff_().length;
+                                    continue;
+                                }
+                        }
+                    }
+                }
+            }
+            idx++;
+        }
+        if (Signed === 0 && SType)
+            Signed = 1;
+        is_negative = (Signed === 1 && !SType) || (Signed !== 1 && SType);
+        if (decs > 0 || digit > 9) {
+            buf = (is_negative ? '-' : ' ') + Pbuf;
+            this.num_4_a_std(buf);
+        }
+        else
+            this.NUM_4_LONG((is_negative ? -1 : 1) * this.a_2_long(Pbuf));
+    }
+    num_4_a_std(str) {
+        let digstr = "";
+        let diglen = 0;
+        let wholes = 0;
+        let decs = 0;
+        let isDec = false;
+        let isminus = false;
+        let pos;
+        for (pos = 0; pos < str.length; pos++) {
+            let c = str.charAt(pos);
+            if (UtilStrByteMode.isDigit(c)) {
+                if (diglen > 0 || c !== '0') {
+                    diglen++;
+                    digstr = digstr + c;
+                    if (!isDec)
+                        wholes++;
+                }
+                else if (isDec)
+                    decs = decs + 1;
+            }
+            else if (c === this.DECIMALCHAR)
+                isDec = true;
+            else if (c === '-')
+                isminus = true;
+        }
+        this.NUM_ZERO();
+        if (diglen === 0)
+            return;
+        if (((wholes + decs) & 1) > 0) {
+            this._data[1] = NUM_TYPE.toSByte(digstr.charCodeAt(0) - '0'.charCodeAt(0));
+            pos = 1;
+        }
+        else
+            pos = 0;
+        let numptr = 1 + pos;
+        diglen = Math.min(diglen, (this.SIGNIFICANT_NUM_SIZE - 1) * 2 - pos);
+        while (pos < diglen) {
+            let digit1 = NUM_TYPE.toSByte((digstr.charCodeAt(pos++) - '0'.charCodeAt(0)));
+            let digit2 = NUM_TYPE.toSByte(((pos < diglen)
+                ? (digstr.charCodeAt(pos++) - '0'.charCodeAt(0))
+                : '\0'.charCodeAt(0)));
+            this._data[numptr++] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(digit1) * 10 + NUM_TYPE.toUByte(digit2));
+        }
+        if (wholes > 0)
+            this._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + ((wholes + 1) >> 1));
+        else
+            this._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS - (decs >> 1));
+        if (isminus)
+            this._data[0] |= NUM_TYPE.SIGN_MASK;
+    }
+    NUM_4_LONG(longVal) {
+        let hexStr;
+        this.NUM_ZERO();
+        if (longVal !== 0) {
+            if (longVal < 0)
+                longVal = (0xFFFFFFFF + longVal + 1);
+            hexStr = longVal.toString(16);
+            if (longVal > 0)
+                hexStr = NUM_TYPE.INT_ZERO_HEX.substr(hexStr.length) + hexStr;
+            this._data[1] = NUM_TYPE.toSByte(parseInt(hexStr.substr(6, (8) - (6)), 16));
+            this._data[2] = NUM_TYPE.toSByte(parseInt(hexStr.substr(4, (6) - (4)), 16));
+            this._data[3] = NUM_TYPE.toSByte(parseInt(hexStr.substr(2, (4) - (2)), 16));
+            this._data[4] = NUM_TYPE.toSByte(parseInt(hexStr.substr(0, (2) - (0)), 16));
+        }
+    }
+    a_2_long(str) {
+        let n = 0;
+        for (let pos = 0; pos < str.length; pos++) {
+            if (UtilStrByteMode.isDigit(str.charAt(pos))) {
+                n = n * 10;
+                n = n + str.charCodeAt(pos) - '0'.charCodeAt(0);
+            }
+        }
+        return n;
+    }
+    to_a(pic) {
+        return this.to_a_pic(pic);
+    }
+    to_a_pic(pic) {
+        let buf = new Array(128);
+        let remains;
+        let sign_n;
+        let pref_len;
+        let suff_len;
+        let pref_str;
+        let suff_str;
+        let str_pos;
+        let str_len;
+        let out_pos;
+        let out_buf;
+        let tmp_out_buf;
+        let pad;
+        let left;
+        let pfill;
+        let mask_chars;
+        let len;
+        let res;
+        let i;
+        let isOut;
+        let outVal;
+        len = pic.getMaskSize();
+        sign_n = (pic.isNegative() && this.num_is_neg() ? false : true);
+        pref_len = (sign_n ? pic.getPosPref_().length : pic.getNegPref_().length);
+        suff_len = (sign_n ? pic.getPosSuff_().length : pic.getNegSuff_().length);
+        left = pic.isLeft();
+        pfill = pic.padFill();
+        mask_chars = pic.getMaskChars();
+        outVal = NString.ToCharArray(pic.getMask().substr(0, len));
+        out_buf = ((left || (mask_chars > 0)) ? buf : outVal);
+        if (left) {
+            for (i = 0; i < out_buf.length; i++)
+                out_buf[i] = '0'.toLowerCase();
+        }
+        isOut = ((left || (mask_chars > 0)) ? false : true);
+        str_pos = pref_len;
+        str_len = len - pref_len - suff_len;
+        tmp_out_buf = out_buf.slice(str_pos, out_buf.length);
+        if (this.NUM_IS_LONG())
+            remains = this.num_l_2_str(this.NUM_LONG(), tmp_out_buf, str_len, pic);
+        else
+            remains = this.to_str(tmp_out_buf, str_len, pic);
+        for (i = str_pos; i < out_buf.length; i++)
+            out_buf[i] = tmp_out_buf[i - str_pos];
+        tmp_out_buf = null;
+        if (remains < mask_chars) {
+            res = new Array(len);
+            for (i = 0; i < len; i++)
+                res[i] = (remains === NUM_TYPE.ZERO_FILL ? pic.getZeroPad() : '*');
+            return NString.FromChars(res);
+        }
+        if (mask_chars > 0) {
+            remains -= mask_chars;
+            str_pos += mask_chars;
+            str_len -= mask_chars;
+        }
+        if (pfill) {
+            pad = pic.getPad();
+            if (left) {
+                for (i = 0; i < remains; i++)
+                    out_buf[str_pos + str_len + i] = pad;
+                str_pos += remains;
+            }
+            else {
+                for (i = 0; i < remains; i++)
+                    out_buf[str_pos + i] = pad;
+            }
+        }
+        else {
+            pad = ' ';
+            str_pos += remains;
+            str_len -= remains;
+        }
+        if (suff_len > 0) {
+            suff_str = sign_n ? pic.getPosSuff_() : pic.getNegSuff_();
+            if (suff_len === 1)
+                out_buf[str_pos + str_len] = suff_str[0];
+            else {
+                for (i = 0; i < suff_len; i++)
+                    out_buf[str_pos + str_len + i] = suff_str[i];
+            }
+            str_len += suff_len;
+        }
+        if (pref_len > 0) {
+            str_pos -= pref_len;
+            str_len += pref_len;
+            pref_str = sign_n ? pic.getPosPref_() : pic.getNegPref_();
+            if (pref_len === 1)
+                out_buf[str_pos] = pref_str[0];
+            else
+                for (i = 0; i < pref_len; i++)
+                    out_buf[str_pos + i] = pref_str[i];
+        }
+        if (!pfill) {
+            let outBufLen = out_buf.length;
+            if (left) {
+                for (i = 0; i < remains && (str_pos + str_len + i < outBufLen); i++)
+                    out_buf[str_pos + str_len + i] = pad;
+            }
+            else {
+                str_pos -= remains;
+                for (i = 0; i < remains && (str_pos + i < outBufLen); i++)
+                    out_buf[str_pos + i] = pad;
+            }
+        }
+        if (isOut)
+            return NString.FromChars(out_buf);
+        if (mask_chars === 0) {
+            if (str_pos + len > out_buf.length)
+                len = out_buf.length - str_pos;
+            return NString.FromChars(out_buf, str_pos, len);
+        }
+        for (out_pos = 0; out_pos < len && str_pos < out_buf.length; out_pos++)
+            if (outVal[out_pos] === String.fromCharCode(PICInterface.PIC_N))
+                outVal[out_pos] = out_buf[str_pos++];
+        return NString.FromChars(outVal);
+    }
+    num_l_2_str(num, str, len, pic) {
+        let commas;
+        let digits;
+        let i;
+        let decs;
+        let j;
+        if (num < 0)
+            num = -num;
+        commas = pic.withComa();
+        decs = Math.min(pic.getDec(), len - 1);
+        if (decs > 0)
+            len -= (decs + 1);
+        i = len;
+        if (num === 0 && !pic.decInFirstPos()) {
+            if (pic.zeroFill())
+                return (NUM_TYPE.ZERO_FILL);
+            if (len === 0)
+                return (NUM_TYPE.NO_ROOM);
+            if (i > str.length)
+                i = str.length;
+            str[--i] = '0';
+        }
+        if (decs > 0) {
+            str[len] = this.DECIMALCHAR;
+            for (j = 0; j < decs; j++)
+                str[len + 1 + j] = '0';
+        }
+        digits = 0;
+        for (; num > 0; num = Math.floor(num / 10)) {
+            i--;
+            if (commas) {
+                if (digits === 3) {
+                    if (i < 0)
+                        return (NUM_TYPE.NO_ROOM);
+                    digits = 0;
+                    str[i--] = this.COMMACHAR;
+                }
+                digits++;
+            }
+            if (i < 0)
+                return (NUM_TYPE.NO_ROOM);
+            str[i] = ((num % 10).toString());
+        }
+        return i;
+    }
+    to_str(str, len, pic) {
+        let tmp;
+        let commas;
+        let digits;
+        let decpos;
+        let last;
+        let first;
+        let j;
+        let i;
+        let decs;
+        let num_char;
+        commas = pic.withComa();
+        decs = pic.getDec();
+        if (decs >= len)
+            decs = len - 1;
+        tmp = new NUM_TYPE(this);
+        tmp.round(decs);
+        if (tmp.NUM_IS_LONG())
+            return tmp.num_l_2_str(tmp.NUM_LONG(), str, len, pic);
+        if (pic.zeroFill() && tmp._data[0] === 0)
+            return (NUM_TYPE.ZERO_FILL);
+        i = len - 1;
+        digits = 0;
+        decpos = ((tmp._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS + 1) * 2;
+        last = decpos - 1 + decs;
+        first = decpos - 1;
+        if (first > 2)
+            first = (tmp._data[1] < 10) ? 3 : 2;
+        for (j = last; j >= first; j--) {
+            if (i < 0)
+                return (NUM_TYPE.NO_ROOM);
+            if (commas && (j < decpos)) {
+                if (digits === 3) {
+                    digits = 0;
+                    str[i--] = this.COMMACHAR;
+                }
+                digits++;
+            }
+            if (i < 0)
+                return (NUM_TYPE.NO_ROOM);
+            if ((j < 2) || (j >= this.SIGNIFICANT_NUM_SIZE * 2))
+                str[i--] = '0';
+            else {
+                if (i < 0)
+                    return (NUM_TYPE.NO_ROOM);
+                num_char = tmp._data[j >> 1];
+                str[i--] = (((j & 1) !== 0) ? (num_char % 10) : (Math.floor(num_char / 10))).toString();
+            }
+            if (j === decpos) {
+                if (i < 0)
+                    return (NUM_TYPE.NO_ROOM);
+                str[i--] = this.DECIMALCHAR;
+                if (i < 0 && pic.decInFirstPos())
+                    return (0);
+            }
+        }
+        return (i + 1);
+    }
+    static add(num1, num2) {
+        let sign1;
+        let sign2;
+        let l;
+        let l1;
+        let l2;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 === null || num2 === null)
+            return null;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        let tmpres = new NUM_TYPE();
+        let res = new NUM_TYPE();
+        let operData = new OperData();
+        if (num1.NUM_IS_LONG()) {
+            if (num2.NUM_IS_LONG()) {
+                l = l1 = num1.NUM_LONG();
+                if (l < 0)
+                    l = -l;
+                if (l < 0x40000000) {
+                    l = l2 = num2.NUM_LONG();
+                    if (l < 0)
+                        l = -l;
+                    if (l < 0x40000000) {
+                        l1 += l2;
+                        res.NUM_4_LONG(l1);
+                        return res;
+                    }
+                }
+                num2.num_4_std_long();
+            }
+            num1.num_4_std_long();
+        }
+        else if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        sign1 = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);
+        sign2 = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);
+        operData.NUM_Diff_ = (operData.NUM_Exp1_ - operData.NUM_Exp2_);
+        let cmpval = operData.NUM_Diff_;
+        if (cmpval === 0) {
+            cmpval = NUM_TYPE.toUByte(num1._data[1]) - NUM_TYPE.toUByte(num2._data[1]);
+            if (cmpval === 0)
+                cmpval = NUM_TYPE.memcmp(num1, 2, num2, 2, SIGNIFICANT_NUM_SIZE - 2);
+        }
+        if (cmpval >= 0) {
+            if (sign1 === sign2)
+                tmpres = NUM_TYPE.add_pos(num1, num2, operData);
+            else
+                tmpres = NUM_TYPE.sub_pos(num1, num2, operData);
+            if (tmpres._data[0] !== 0)
+                tmpres._data[0] = NUM_TYPE.toSByte(tmpres._data[0] | sign1);
+        }
+        else {
+            let exp = operData.NUM_Exp1_;
+            operData.NUM_Exp1_ = operData.NUM_Exp2_;
+            operData.NUM_Exp2_ = exp;
+            operData.NUM_Diff_ = -operData.NUM_Diff_;
+            if (sign1 === sign2)
+                tmpres = NUM_TYPE.add_pos(num2, num1, operData);
+            else
+                tmpres = NUM_TYPE.sub_pos(num2, num1, operData);
+            if (tmpres._data[0] !== 0)
+                tmpres._data[0] |= sign2;
+        }
+        return tmpres;
+    }
+    static sub(num1, num2) {
+        if (num1 === null || num2 === null)
+            return null;
+        let tmpres = new NUM_TYPE();
+        let res = new NUM_TYPE();
+        let operData = new OperData();
+        if (num1.NUM_IS_LONG()) {
+            if (num2.NUM_IS_LONG()) {
+                let l;
+                let l1 = l = num1.NUM_LONG();
+                if (l < 0)
+                    l = -l;
+                if (l < 0x40000000) {
+                    let l2 = l = num2.NUM_LONG();
+                    if (l < 0)
+                        l = -l;
+                    if (l < 0x40000000) {
+                        l1 -= l2;
+                        res.NUM_4_LONG(l1);
+                        return res;
+                    }
+                }
+                num2.num_4_std_long();
+            }
+            num1.num_4_std_long();
+        }
+        else if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        let sign1 = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);
+        let sign2 = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);
+        operData.NUM_Diff_ = (operData.NUM_Exp1_ - operData.NUM_Exp2_);
+        let cmpval = operData.NUM_Diff_;
+        if (cmpval === 0) {
+            cmpval = NUM_TYPE.toUByte(num1._data[1]) - NUM_TYPE.toUByte(num2._data[1]);
+            if (cmpval === 0)
+                cmpval = NUM_TYPE.memcmp(num1, 2, num2, 2, GuiEnvironment.Environment.GetSignificantNumSize() - 2);
+        }
+        if (cmpval >= 0) {
+            if (sign1 === sign2)
+                tmpres = NUM_TYPE.sub_pos(num1, num2, operData);
+            else
+                tmpres = NUM_TYPE.add_pos(num1, num2, operData);
+        }
+        else {
+            let exp = operData.NUM_Exp1_;
+            operData.NUM_Exp1_ = operData.NUM_Exp2_;
+            operData.NUM_Exp2_ = exp;
+            operData.NUM_Diff_ = -operData.NUM_Diff_;
+            if (sign1 === sign2) {
+                tmpres = NUM_TYPE.sub_pos(num2, num1, operData);
+                sign1 ^= (NUM_TYPE.SIGN_MASK);
+            }
+            else
+                tmpres = NUM_TYPE.add_pos(num2, num1, operData);
+        }
+        if (tmpres._data[0] !== 0)
+            tmpres._data[0] |= sign1;
+        return tmpres;
+    }
+    static mul(num1, num2) {
+        let fullres = new Int8Array(38);
+        let pwr;
+        let len1;
+        let len2;
+        let pos1;
+        let pos2;
+        let pos;
+        let digit1;
+        let prod;
+        let carry;
+        let l;
+        let l1;
+        let l2;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 === null || num2 === null)
+            return null;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        let res = new NUM_TYPE();
+        let operData = new OperData();
+        let i;
+        let tmpByte;
+        if (num1.NUM_IS_LONG()) {
+            if (num2.NUM_IS_LONG()) {
+                l = l1 = num1.NUM_LONG();
+                if (l < 0)
+                    l = -l;
+                if (l < 0xB000) {
+                    l = l2 = num2.NUM_LONG();
+                    if (l < 0)
+                        l = -l;
+                    if (l < 0xB000) {
+                        l1 = l1 * l2;
+                        res.NUM_4_LONG(l1);
+                        return res;
+                    }
+                }
+                num2.num_4_std_long();
+            }
+            num1.num_4_std_long();
+        }
+        else if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);
+        if (operData.NUM_Exp1_ === 0 || operData.NUM_Exp2_ === 0) {
+            res.NUM_ZERO();
+            return res;
+        }
+        for (len1 = SIGNIFICANT_NUM_SIZE - 1; num1._data[len1] === 0; len1--) {
+        }
+        for (len2 = SIGNIFICANT_NUM_SIZE - 1; num2._data[len2] === 0; len2--) {
+        }
+        for (i = 0; i < (NUM_TYPE.NUM_SIZE - 1) * 2; i++)
+            fullres[i] = 0;
+        pos = 0;
+        for (pos1 = len1; pos1 > 0; pos1--) {
+            pos = pos1 + len2 - 1;
+            digit1 = num1._data[pos1];
+            carry = 0;
+            for (pos2 = len2; pos2 > 0; pos2--) {
+                prod = NUM_TYPE.toUByte(digit1) * NUM_TYPE.toUByte(num2._data[pos2]) + carry;
+                carry = Math.floor(prod / 100);
+                fullres[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(fullres[pos]) + prod % 100);
+                tmpByte = fullres[pos];
+                pos--;
+                if (NUM_TYPE.toUByte(tmpByte) >= 100) {
+                    fullres[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(fullres[pos + 1]) - 100);
+                    carry++;
+                }
+            }
+            fullres[pos] = NUM_TYPE.toSByte(carry);
+        }
+        pwr = NUM_TYPE.toUByte(operData.NUM_Exp1_) - NUM_TYPE.EXP_BIAS + (NUM_TYPE.toUByte(operData.NUM_Exp2_) - NUM_TYPE.EXP_BIAS);
+        if (fullres[0] === 0) {
+            pos++;
+            pwr--;
+        }
+        if ((num1._data[0] & NUM_TYPE.SIGN_MASK) === (num2._data[0] & NUM_TYPE.SIGN_MASK))
+            res._data[0] = 0;
+        else
+            res._data[0] = NUM_TYPE.SIGN_MASK;
+        res._data[0] |= NUM_TYPE.toSByte(pwr + NUM_TYPE.EXP_BIAS);
+        for (i = 0; i < SIGNIFICANT_NUM_SIZE - 1; i++)
+            res._data[1 + i] = fullres[pos + i];
+        return res;
+    }
+    static mod(num1, num2) {
+        if (num1 === null || num2 === null)
+            return null;
+        let res = new NUM_TYPE();
+        if (num2.num_is_zero()) {
+            res.NUM_ZERO();
+            return res;
+        }
+        if (num1.NUM_IS_LONG())
+            num1.num_4_std_long();
+        if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        res = NUM_TYPE.div(num1, num2);
+        res.num_trunc(0);
+        res = NUM_TYPE.mul(res, num2);
+        res = NUM_TYPE.sub(num1, res);
+        return res;
+    }
+    static div(num1, num2) {
+        let dividend = new Int8Array((NUM_TYPE.NUM_SIZE - 1) * 2);
+        let divisor = new Int8Array(NUM_TYPE.NUM_SIZE);
+        let pwr;
+        let len1;
+        let len2;
+        let pos1;
+        let pos2;
+        let pos;
+        let quot;
+        let prod;
+        let carry;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 === null || num2 === null)
+            return null;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        let res = new NUM_TYPE();
+        let operData = new OperData();
+        let i;
+        let tmpByte;
+        if (num1.NUM_IS_LONG())
+            num1.num_4_std_long();
+        if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);
+        operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);
+        if (operData.NUM_Exp1_ === 0 || operData.NUM_Exp2_ === 0) {
+            res.NUM_ZERO();
+            return res;
+        }
+        for (len1 = SIGNIFICANT_NUM_SIZE - 1; num1._data[len1] === 0; len1--) {
+        }
+        for (len2 = SIGNIFICANT_NUM_SIZE - 1; num2._data[len2] === 0; len2--) {
+        }
+        pos = (NUM_TYPE.memcmp(num1, 1, num2, 1, len2) < 0) ? 0 : 1;
+        for (i = 0; i < (NUM_TYPE.NUM_SIZE - 1) * 2; i++)
+            dividend[i] = 0;
+        for (i = 0; i < len1; i++)
+            dividend[pos + i] = num1._data[1 + i];
+        for (i = 0; i < len2; i++)
+            divisor[1 + i] = num2._data[1 + i];
+        res.NUM_SET_ZERO();
+        pwr = NUM_TYPE.toUByte(operData.NUM_Exp1_) - NUM_TYPE.toUByte(operData.NUM_Exp2_) + pos;
+        res._data[0] = NUM_TYPE.toSByte(pwr + NUM_TYPE.EXP_BIAS);
+        if ((num1._data[0] & NUM_TYPE.SIGN_MASK) !== (num2._data[0] & NUM_TYPE.SIGN_MASK))
+            res._data[0] |= NUM_TYPE.SIGN_MASK;
+        quot = Math.floor(100 / (NUM_TYPE.toUByte(divisor[1]) + 1));
+        if (quot > 1) {
+            carry = 0;
+            for (pos2 = len2; pos2 > 0; pos2--) {
+                prod = quot * NUM_TYPE.toUByte(divisor[pos2]) + carry;
+                carry = Math.floor(prod / 100);
+                divisor[pos2] = NUM_TYPE.toSByte(prod % 100);
+            }
+            carry = 0;
+            for (pos1 = len1 + pos - 1; pos1 >= 0; pos1--) {
+                prod = quot * NUM_TYPE.toUByte(dividend[pos1]) + carry;
+                carry = Math.floor(prod / 100);
+                dividend[pos1] = NUM_TYPE.toSByte(prod % 100);
+            }
+        }
+        for (pos1 = 1; pos1 < SIGNIFICANT_NUM_SIZE; pos1++) {
+            quot = NUM_TYPE.toUByte(dividend[pos1 - 1]) * 100 + Math.floor(NUM_TYPE.toUByte(dividend[pos1]) / NUM_TYPE.toUByte(divisor[1]));
+            if (quot >= 100)
+                quot = 99;
+            if (quot !== 0) {
+                pos = pos1 + len2 - 1;
+                carry = 0;
+                for (pos2 = len2; pos2 > 0; pos2--) {
+                    prod = quot * NUM_TYPE.toUByte(divisor[pos2]) + carry;
+                    carry = Math.floor(prod / 100);
+                    dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) - prod % 100);
+                    tmpByte = dividend[pos];
+                    pos--;
+                    if (tmpByte < 0) {
+                        dividend[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos + 1]) + 100);
+                        carry++;
+                    }
+                }
+                dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) - carry);
+                while (dividend[pos] < 0) {
+                    quot--;
+                    pos = pos1 + len2 - 1;
+                    for (pos2 = len2; pos2 > 0; pos2--) {
+                        dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) + NUM_TYPE.toUByte(divisor[pos2]));
+                        tmpByte = dividend[pos];
+                        pos--;
+                        if (NUM_TYPE.toUByte(tmpByte) >= 100) {
+                            dividend[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos + 1]) - 100);
+                            dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) + 1);
+                        }
+                    }
+                }
+            }
+            res._data[pos1] = NUM_TYPE.toSByte(quot);
+        }
+        return res;
+    }
+    static num_cmp(num1, num2) {
+        let sign1;
+        let sign2;
+        let cmpval;
+        let l1;
+        let l2;
+        let tmp;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 == null || num2 == null)
+            return Int32.MinValue;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        if (num1.NUM_IS_LONG()) {
+            if (num2.NUM_IS_LONG()) {
+                l1 = num1.NUM_LONG();
+                l2 = num2.NUM_LONG();
+                if (l1 >= 0 && l2 >= 0) {
+                    tmp = l1 - l2;
+                    if (tmp === 0)
+                        return (0);
+                    if (tmp > 0)
+                        return (1);
+                    return (-1);
+                }
+                num2.num_4_std_long();
+            }
+            num1.num_4_std_long();
+        }
+        else if (num2.NUM_IS_LONG())
+            num2.num_4_std_long();
+        sign1 = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);
+        sign2 = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);
+        cmpval = (sign1 === sign2)
+            ? NUM_TYPE.memcmp(num1, 0, num2, 0, SIGNIFICANT_NUM_SIZE)
+            : 1;
+        if (sign1 !== 0)
+            cmpval = -cmpval;
+        return (cmpval);
+    }
+    static numHexStrIsLong(numHexStr) {
+        return numHexStr.substr(0, 2) === "FF";
+    }
+    NUM_ZERO() {
+        this.setZero(true);
+    }
+    NUM_SET_ZERO() {
+        this.setZero(false);
+    }
+    num_is_neg() {
+        if (this.NUM_IS_LONG())
+            return ((this._data[4] & 0x80) !== 0);
+        return ((this._data[0] & NUM_TYPE.SIGN_MASK) !== 0);
+    }
+    num_is_zero() {
+        if (this.NUM_IS_LONG())
+            return (this.NUM_LONG() === 0);
+        return (this._data[0] === 0);
+    }
+    num_neg() {
+        let l;
+        if (this.NUM_IS_LONG()) {
+            l = -this.NUM_LONG();
+            this.NUM_4_LONG(l);
+            return;
+        }
+        if (this._data[0] !== 0)
+            this._data[0] ^= NUM_TYPE.SIGN_MASK;
+    }
+    NUM_IS_LONG() {
+        return this._data[0] === NUM_TYPE.NUM_LONG_TYPE;
+    }
+    NUM_LONG() {
+        if (this._data[1] === 0 && this._data[2] === 0 && this._data[3] === 0 && this._data[4] === -128)
+            return Int32.MinValue;
+        let dataview = new DataView(this._data.buffer);
+        return dataview.getInt32(1, true);
+    }
+    round(decs) {
+        let addval;
+        if (this.NUM_IS_LONG())
+            return;
+        addval = new NUM_TYPE();
+        addval._data[0] = NUM_TYPE.toSByte((this._data[0] & NUM_TYPE.SIGN_MASK) | (NUM_TYPE.EXP_BIAS - (decs >> 1)));
+        addval._data[1] = NUM_TYPE.toSByte((decs & 1) !== 0 ? 5 : 50);
+        let temp = NUM_TYPE.add(this, addval);
+        this._data = new Int8Array(temp._data.length);
+        this._data = temp._data;
+        this.num_trunc(decs);
+    }
+    dbRound(whole) {
+        let addval;
+        let pwr;
+        let num_diff;
+        let i;
+        if (this.NUM_IS_LONG())
+            return;
+        addval = new NUM_TYPE();
+        addval._data[0] = NUM_TYPE.toSByte((this._data[0] & NUM_TYPE.SIGN_MASK) | (NUM_TYPE.EXP_BIAS + ((whole + 1) >> 1)));
+        addval._data[1] = NUM_TYPE.toSByte(((whole & 1) !== 0) ? 5 : 50);
+        let temp = NUM_TYPE.add(this, addval);
+        this._data = new Int8Array(temp._data.length);
+        for (let _ai = 0; _ai < this._data.length; ++_ai)
+            this._data[_ai] = temp._data[_ai];
+        pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;
+        if ((num_diff = pwr - ((whole + 1) >> 1)) >= 0) {
+            if ((whole & 1) !== 0) {
+                this._data[1 + num_diff] = NUM_TYPE.toSByte(this._data[1 + num_diff] - this._data[1 + num_diff] % 10);
+                num_diff++;
+            }
+            for (i = 0; i < this.SIGNIFICANT_NUM_SIZE - (1 + num_diff); i++)
+                this._data[1 + num_diff + i] = 0;
+        }
+        else
+            this.NUM_SET_ZERO();
+    }
+    num_trunc(decs) {
+        let pwr;
+        let num_diff;
+        let i;
+        if (this.NUM_IS_LONG())
+            return;
+        pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;
+        if ((num_diff = this.SIGNIFICANT_NUM_SIZE - 1 - pwr - ((decs + 1) >> 1)) < 0)
+            return;
+        if ((num_diff < this.SIGNIFICANT_NUM_SIZE - 1) && ((decs & 1) !== 0)) {
+            this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] =
+                NUM_TYPE.toSByte(this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] - this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] % 10);
+            if (this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] === 0)
+                num_diff++;
+        }
+        if (num_diff >= this.SIGNIFICANT_NUM_SIZE - 1) {
+            this.NUM_ZERO();
+            return;
+        }
+        for (i = 0; i < num_diff; i++)
+            this._data[this.SIGNIFICANT_NUM_SIZE - num_diff + i] = 0;
+    }
+    num_4_std_long() {
+        let slong;
+        slong = this.NUM_LONG();
+        if (slong >= 0)
+            this.num_4_ulong(slong);
+        else {
+            this.num_4_ulong(-slong);
+            this._data[0] |= NUM_TYPE.SIGN_MASK;
+        }
+    }
+    num_4_ulong(data) {
+        let pwr;
+        let pos;
+        let i;
+        this.NUM_SET_ZERO();
+        pos = pwr = 5;
+        while (data > 0) {
+            this._data[pos--] = NUM_TYPE.toSByte(data % 100);
+            data = Math.floor(data / 100);
+        }
+        if (pos < pwr) {
+            if (pos > 0) {
+                for (i = 0; i < pwr - pos; i++)
+                    this._data[1 + i] = this._data[1 + pos + i];
+                for (i = 0; i < pos; i++)
+                    this._data[pwr - pos + 1 + i] = 0;
+            }
+            this._data[0] = NUM_TYPE.toSByte(pwr - pos + NUM_TYPE.EXP_BIAS);
+        }
+    }
+    NUM_2_LONG() {
+        if (this.NUM_IS_LONG())
+            return this.NUM_LONG();
+        else
+            return this.num_2_long();
+    }
+    NUM_2_ULONG() {
+        if (this.NUM_IS_LONG())
+            return this.NUM_LONG();
+        else
+            return this.num_2_ulong();
+    }
+    num_2_long() {
+        let slong;
+        let sign;
+        sign = this._data[0] & NUM_TYPE.SIGN_MASK;
+        this._data[0] &= NUM_TYPE.toSByte(~NUM_TYPE.SIGN_MASK);
+        if (sign !== 0) {
+            if (NUM_TYPE.memcmp(this, 0, NUM_TYPE.MinLONG(), 0, this.SIGNIFICANT_NUM_SIZE) > 0)
+                return 0;
+        }
+        else {
+            if (NUM_TYPE.memcmp(this, 0, NUM_TYPE.MaxLONG(), 0, this.SIGNIFICANT_NUM_SIZE) > 0)
+                return 0;
+        }
+        slong = this.num_2_ulong();
+        if (sign !== 0) {
+            slong = -slong;
+            this._data[0] |= NUM_TYPE.toSByte(sign);
+        }
+        return (slong);
+    }
+    num_2_ulong() {
+        let val;
+        let pwr;
+        let pos;
+        let last;
+        pwr = this._data[0] - NUM_TYPE.EXP_BIAS;
+        if (pwr > 5)
+            return (0);
+        last = (pwr === 5);
+        if (last)
+            pwr = 4;
+        val = 0;
+        for (pos = 1; pos <= pwr; pos++)
+            val = val * 100 + NUM_TYPE.toUByte(this._data[pos]);
+        if (last)
+            if (val <= Math.floor((0xFFFFFFFF - NUM_TYPE.toUByte(this._data[5])) / 100))
+                val = val * 100 + NUM_TYPE.toUByte(this._data[5]);
+            else
+                val = 0;
+        return (val);
+    }
+    static add_pos(num1, num2, operData) {
+        let len1;
+        let len2;
+        let len;
+        let pos;
+        let num1ptr;
+        let resptr;
+        let i;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 == null || num2 == null)
+            return null;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        let res = new NUM_TYPE();
+        if (operData.NUM_Exp2_ === 0 || (operData.NUM_Diff_ >= SIGNIFICANT_NUM_SIZE - 1)) {
+            res = new NUM_TYPE(num1);
+            res._data[0] = operData.NUM_Exp1_;
+            return res;
+        }
+        len1 = 1;
+        for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {
+            if (num1.SHRT_IS_ZERO(i))
+                continue;
+            else {
+                len1 = i + 1;
+                break;
+            }
+        }
+        if (num1._data[len1] === 0)
+            len1--;
+        len2 = 1;
+        for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {
+            if (num2.SHRT_IS_ZERO(i))
+                continue;
+            else {
+                len2 = i + 1;
+                break;
+            }
+        }
+        if (num2._data[len2] === 0)
+            len2--;
+        if ((len = Math.max(len1, len2 + operData.NUM_Diff_)) > SIGNIFICANT_NUM_SIZE - 1)
+            len = SIGNIFICANT_NUM_SIZE - 1;
+        res.NUM_SET_ZERO();
+        num1ptr = operData.NUM_Diff_;
+        resptr = operData.NUM_Diff_;
+        for (pos = len - operData.NUM_Diff_; pos > 0; pos--) {
+            res._data[resptr + pos] =
+                NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + NUM_TYPE.toUByte(num1._data[num1ptr + pos]) + NUM_TYPE.toUByte(num2._data[pos]));
+            if (NUM_TYPE.toUByte(res._data[resptr + pos]) >= 100) {
+                res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) - 100);
+                res._data[resptr + pos - 1] = 1;
+            }
+        }
+        for (pos = operData.NUM_Diff_; pos > 0; pos--) {
+            res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + NUM_TYPE.toUByte(num1._data[pos]));
+            if (NUM_TYPE.toUByte(res._data[pos]) >= 100) {
+                res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) - 100);
+                res._data[pos - 1] = 1;
+            }
+        }
+        if (res._data[0] !== 0) {
+            for (pos = Math.min(len, SIGNIFICANT_NUM_SIZE - 2); pos >= 0; pos--)
+                res._data[pos + 1] = res._data[pos];
+            operData.NUM_Exp1_++;
+        }
+        res._data[0] = operData.NUM_Exp1_;
+        return res;
+    }
+    static sub_pos(num1, num2, operData) {
+        let len1;
+        let len2;
+        let len;
+        let pos;
+        let num1ptr;
+        let resptr;
+        let i;
+        let SIGNIFICANT_NUM_SIZE;
+        if (num1 == null || num2 == null)
+            return null;
+        SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();
+        let res = new NUM_TYPE();
+        let j;
+        if (operData.NUM_Exp2_ === 0 || (operData.NUM_Diff_ >= SIGNIFICANT_NUM_SIZE - 1)) {
+            res = new NUM_TYPE(num1);
+            res._data[0] = operData.NUM_Exp1_;
+            return res;
+        }
+        len1 = 1;
+        for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {
+            if (num1.SHRT_IS_ZERO(i))
+                continue;
+            else {
+                len1 = i + 1;
+                break;
+            }
+        }
+        if (num1._data[len1] === 0)
+            len1--;
+        len2 = 1;
+        for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {
+            if (num2.SHRT_IS_ZERO(i))
+                continue;
+            else {
+                len2 = i + 1;
+                break;
+            }
+        }
+        if (num2._data[len2] === 0)
+            len2--;
+        if ((len = Math.max(len1, len2 + operData.NUM_Diff_)) > SIGNIFICANT_NUM_SIZE - 1)
+            len = SIGNIFICANT_NUM_SIZE - 1;
+        res.NUM_SET_ZERO();
+        num1ptr = operData.NUM_Diff_;
+        resptr = operData.NUM_Diff_;
+        for (pos = len - operData.NUM_Diff_; pos > 0; pos--) {
+            res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + NUM_TYPE.toUByte(num1._data[num1ptr + pos]) - NUM_TYPE.toUByte(num2._data[pos]));
+            if (res._data[resptr + pos] < 0) {
+                res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + 100);
+                res._data[resptr + pos - 1] = NUM_TYPE.toSByte(0xFF);
+            }
+        }
+        for (pos = operData.NUM_Diff_; pos > 0; pos--) {
+            res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + NUM_TYPE.toUByte(num1._data[pos]));
+            if (res._data[pos] < 0) {
+                res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + 100);
+                res._data[pos - 1] = NUM_TYPE.toSByte(0xFF);
+            }
+        }
+        while ((++pos <= len) && res._data[pos] === 0) {
+        }
+        if (pos <= len) {
+            operData.NUM_Diff_ = pos - 1;
+            if (operData.NUM_Diff_ > 0) {
+                for (j = 0; j < len - operData.NUM_Diff_; j++)
+                    res._data[1 + j] = res._data[pos + j];
+                for (j = 0; j < operData.NUM_Diff_; j++)
+                    res._data[len - operData.NUM_Diff_ + 1 + j] = 0;
+            }
+            res._data[0] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(operData.NUM_Exp1_) - operData.NUM_Diff_);
+        }
+        return res;
+    }
+    num_fix(wholes) {
+        let pwr;
+        let num_diff;
+        if (this.NUM_IS_LONG())
+            this.num_4_std_long();
+        pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;
+        if ((num_diff = pwr - ((wholes + 1) >> 1)) < 0)
+            return;
+        if (num_diff < this.SIGNIFICANT_NUM_SIZE - 1) {
+            if ((wholes & 1) === 1)
+                this._data[1 + num_diff] = NUM_TYPE.toSByte(this._data[1 + num_diff] % 10);
+            while ((num_diff < this.SIGNIFICANT_NUM_SIZE - 1) && this._data[1 + num_diff] === 0)
+                num_diff++;
+        }
+        if (num_diff >= this.SIGNIFICANT_NUM_SIZE - 1) {
+            this.NUM_ZERO();
+            return;
+        }
+        if (num_diff > 0) {
+            let i;
+            for (i = 0; i < this.SIGNIFICANT_NUM_SIZE - 1 - num_diff; i++)
+                this._data[1 + i] = this._data[1 + num_diff + i];
+            for (i = 0; i < num_diff; i++)
+                this._data[this.SIGNIFICANT_NUM_SIZE - num_diff + i] = 0;
+            this._data[0] = NUM_TYPE.toSByte(this._data[0] - NUM_TYPE.toSByte(num_diff));
+        }
+    }
+    SHRT_IS_ZERO(pos) {
+        return this._data[pos] === 0 && this._data[pos + 1] === 0;
+    }
+    setZero(asLong) {
+        let i;
+        for (i = 0; i < NUM_TYPE.NUM_SIZE; i++)
+            this._data[i] = 0;
+        if (asLong)
+            this._data[0] = NUM_TYPE.NUM_LONG_TYPE;
+    }
+    static memcmp(num1, pos1, num2, pos2, len) {
+        let i = 0;
+        while (i < len && num1._data[pos1] === num2._data[pos2] && pos1 < NUM_TYPE.NUM_SIZE && pos2 < NUM_TYPE.NUM_SIZE) {
+            i++;
+            pos1++;
+            pos2++;
+        }
+        if (i === len)
+            return 0;
+        else if (this.toUByte(num1._data[pos1]) < this.toUByte(num2._data[pos2]))
+            return -1;
+        else
+            return 1;
+    }
+    static toUByte(byteVal) {
+        let val = byteVal;
+        if (byteVal < 0)
+            val = 256 + byteVal;
+        return val;
+    }
+    static toSByte(unsignedVal) {
+        let val = 0;
+        if (unsignedVal > Constants.SByteMaxValue)
+            val = (unsignedVal - 256);
+        else
+            val = unsignedVal;
+        return val;
+    }
+    static MaxLONG() {
+        let nUM_TYPE = new NUM_TYPE();
+        nUM_TYPE._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5);
+        nUM_TYPE._data[1] = 21;
+        nUM_TYPE._data[2] = 47;
+        nUM_TYPE._data[3] = 48;
+        nUM_TYPE._data[4] = 36;
+        nUM_TYPE._data[5] = 47;
+        return nUM_TYPE;
+    }
+    static MinLONG() {
+        let num = new NUM_TYPE();
+        num._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5);
+        num._data[1] = 21;
+        num._data[2] = 47;
+        num._data[3] = 48;
+        num._data[4] = 36;
+        num._data[5] = 48;
+        return num;
+    }
+    to_double() {
+        return this.storage_mg_2_float(8);
+    }
+    storage_mg_2_float(len) {
+        let sign_pos;
+        let sign;
+        let compnum = new NUM_TYPE();
+        let tmpnum = new NUM_TYPE();
+        let divnum = new NUM_TYPE();
+        let pwr;
+        let bits;
+        let exp;
+        let long1 = 0;
+        let long2 = 0;
+        let fltOut = 0;
+        let cout = new Int8Array([0, 0, 0, 0, 0, 0, 0, 0]);
+        let Num2Pwr23_ = new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 8, 38, 86, 8]);
+        let Num2Pwr52_ = new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]);
+        let base_Num16Pwrs = [
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 2, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 40, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 3), 6, 55, 36]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 1, 4, 85, 76]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 16, 77, 72, 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 2, 68, 43, 54, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 42, 94, 96, 72, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 6), 6, 87, 19, 47, 67, 36]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 1, 9, 95, 11, 62, 77, 76]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 17, 59, 21, 86, 4, 44, 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 2, 81, 47, 49, 76, 71, 6, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 9), 7, 20, 57, 59, 40, 37, 92, 79, 36])
+        ];
+        let base_Num2Pwrs = [
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 2]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 4]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 8])
+        ];
+        if (this.NUM_IS_LONG())
+            this.num_4_std_long();
+        if (this._data[0] === 0)
+            return 0;
+        sign = NUM_TYPE.toSByte(this._data[0] & NUM_TYPE.SIGN_MASK);
+        this._data[0] = NUM_TYPE.toSByte(this._data[0] & (~NUM_TYPE.SIGN_MASK));
+        if (len === 4) {
+            bits = 24;
+            compnum = new NUM_TYPE(Num2Pwr23_);
+        }
+        else {
+            bits = 53;
+            compnum = new NUM_TYPE(Num2Pwr52_);
+        }
+        pwr = (this._data[0] - NUM_TYPE.EXP_BIAS) << 1;
+        if (pwr < 0)
+            exp = pwr * 3 + Math.floor((pwr + 1) / 3);
+        else
+            exp = pwr * 3 + Math.floor((pwr + 2) / 3);
+        pwr = bits - exp;
+        if (pwr < 0) {
+            pwr = -pwr;
+            tmpnum = NUM_TYPE.div(this, new NUM_TYPE(base_Num16Pwrs[pwr >> 2]));
+            tmpnum = NUM_TYPE.div(tmpnum, new NUM_TYPE(base_Num2Pwrs[pwr & 3]));
+        }
+        else {
+            tmpnum = this;
+            while (pwr >= 60) {
+                tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[14]));
+                pwr -= 56;
+            }
+            tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[pwr >> 2]));
+            tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num2Pwrs[pwr & 3]));
+        }
+        while (NUM_TYPE.num_cmp(tmpnum, compnum) < 0) {
+            exp--;
+            tmpnum = NUM_TYPE.add(tmpnum, tmpnum);
+        }
+        if (len === 4) {
+            long1 = tmpnum.num_2_ulong();
+        }
+        else {
+            divnum = NUM_TYPE.div(tmpnum, new NUM_TYPE(base_Num16Pwrs[8]));
+            divnum.num_trunc(0);
+            long1 = divnum.num_2_ulong();
+            divnum = NUM_TYPE.mul(divnum, new NUM_TYPE(base_Num16Pwrs[8]));
+            divnum = NUM_TYPE.sub(tmpnum, divnum);
+            long2 = divnum.num_2_ulong();
+        }
+        sign_pos = len - 1;
+        if (len === 4) {
+            exp += 126;
+            cout[3] = NUM_TYPE.toSByte(exp >> 1);
+            cout[2] = NUM_TYPE.toSByte((this.LO_CHAR(this.HI_SHRT(long1)) & 0x7F) | ((exp & 0x01) << 7));
+            cout[1] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long1)));
+            cout[0] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long1)));
+        }
+        else {
+            exp += 1022;
+            cout[7] = NUM_TYPE.toSByte(exp >> 4);
+            cout[6] = NUM_TYPE.toSByte((this.LO_CHAR(this.HI_SHRT(long1)) & 0x0F) | ((exp & 0x0F) << 4));
+            cout[5] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long1)));
+            cout[4] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long1)));
+            cout[3] = NUM_TYPE.toSByte(this.HI_CHAR(this.HI_SHRT(long2)));
+            cout[2] = NUM_TYPE.toSByte(this.LO_CHAR(this.HI_SHRT(long2)));
+            cout[1] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long2)));
+            cout[0] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long2)));
+        }
+        if (sign !== 0) {
+            cout[sign_pos] |= NUM_TYPE.SIGN_MASK;
+            this._data[0] |= NUM_TYPE.SIGN_MASK;
+        }
+        fltOut = this.sbyteArr_2_Double(cout);
+        return fltOut;
+    }
+    LO_CHAR(n) {
+        return n & 255;
+    }
+    HI_CHAR(n) {
+        return (n & 65280) >> 8;
+    }
+    LO_SHRT(n) {
+        return (n & 65535);
+    }
+    HI_SHRT(n) {
+        return ((n & -65536) >> 16);
+    }
+    static MK_SHRT(c1, c2) {
+        let strInt = (c1 << 8 | c2).toString();
+        return NNumber.Parse(strInt);
+    }
+    static MK_LONG(s1, s2) {
+        let l1 = s1;
+        let l2 = s2;
+        let strLng = (l1 << 16 | l2).toString();
+        return NNumber.Parse(strLng);
+    }
+    sbyteArr_2_Double(array) {
+        let dataview = new DataView(array.buffer);
+        return dataview.getFloat64(0, true);
+    }
+    static double_2_sbyteArray(d) {
+        let buffer = new ArrayBuffer(8);
+        let dataview = new DataView(buffer);
+        dataview.setFloat64(0, d, true);
+        return (new Int8Array(dataview.buffer));
+    }
+    static eval_op_pwr(num1, num2) {
+        let d0;
+        let d1;
+        if (num1 == null || num2 == null)
+            return null;
+        if (num2.NUM_IS_LONG() && !num2.num_is_neg()) {
+            d1 = num2.to_double();
+            let result = NUM_TYPE.from_double(1);
+            for (let i = 0; i < d1; i++)
+                result = this.mul(result, num1);
+            return result;
+        }
+        else {
+            d0 = num1.to_double();
+            d1 = num2.to_double();
+            if (d0 < 0.0 && d1 !== d1)
+                d0 = 0.0;
+            else if (d0 !== 0.0)
+                d0 = Math.pow(d0, d1);
+        }
+        return NUM_TYPE.from_double(d0);
+    }
+    static from_double(d0) {
+        let array = NUM_TYPE.double_2_sbyteArray(d0);
+        return NUM_TYPE.storage_mg_4_float(8, array);
+    }
+    static storage_mg_4_float(len, inp) {
+        let cinp;
+        let sign;
+        let tmp1;
+        let exp;
+        let bias;
+        let long1;
+        let long2;
+        cinp = new Array(inp.length);
+        for (tmp1 = 0; tmp1 < inp.length; tmp1++)
+            cinp[tmp1] = NUM_TYPE.toUByte(inp[tmp1]);
+        sign = cinp[len - 1];
+        if (len === 4) {
+            exp = ((cinp[2] >> 7) | ((cinp[3] & 0x7F) << 1));
+            bias = 150;
+            long1 = 0;
+            long2 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(0, cinp[2] | 0x80), NUM_TYPE.MK_SHRT(cinp[1], cinp[0]));
+        }
+        else {
+            exp = (((cinp[7] & 0x7F) << 4) | (cinp[6] >> 4));
+            bias = 1075;
+            long1 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(0, (cinp[6] & 0x0F) | 0x10), NUM_TYPE.MK_SHRT(cinp[5], cinp[4]));
+            long2 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(cinp[3], cinp[2]), NUM_TYPE.MK_SHRT(cinp[1], cinp[0]));
+        }
+        return NUM_TYPE.storage_num_4_fld_flt(long1, long2, 18, sign, bias, exp);
+    }
+    static storage_num_4_fld_flt(long1, long2, dec, sign, bias, expr) {
+        let base_Num16Pwrs = [
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 2, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 40, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 3), 6, 55, 36]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 1, 4, 85, 76]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 16, 77, 72, 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 2, 68, 43, 54, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 42, 94, 96, 72, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 6), 6, 87, 19, 47, 67, 36]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 1, 9, 95, 11, 62, 77, 76]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 17, 59, 21, 86, 4, 44, 16]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 2, 81, 47, 49, 76, 71, 6, 56]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 9), 7, 20, 57, 59, 40, 37, 92, 79, 36])
+        ];
+        let base_Num2Pwrs = [
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 2]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 4]),
+            new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 8])
+        ];
+        let tmpnum = new NUM_TYPE();
+        let outVal = new NUM_TYPE();
+        let exp = expr;
+        if (exp === 0) {
+            outVal.NUM_ZERO();
+            return outVal;
+        }
+        outVal.num_4_ulong(long2);
+        if (long1 !== 0) {
+            tmpnum.num_4_ulong(long1);
+            tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[8]));
+            outVal = NUM_TYPE.add(tmpnum, outVal);
+        }
+        exp = (exp - bias);
+        if (exp < 0) {
+            exp = -exp;
+            while (exp >= 60) {
+                outVal = NUM_TYPE.div(outVal, new NUM_TYPE(base_Num16Pwrs[14]));
+                exp -= 56;
+            }
+            tmpnum = NUM_TYPE.mul(new NUM_TYPE(base_Num16Pwrs[exp >> 2]), new NUM_TYPE(base_Num2Pwrs[exp & 3]));
+            outVal = NUM_TYPE.div(outVal, tmpnum);
+        }
+        else {
+            if (exp >= 60) {
+                outVal.NUM_ZERO();
+                return outVal;
+            }
+            tmpnum = NUM_TYPE.mul(new NUM_TYPE(base_Num16Pwrs[exp >> 2]), new NUM_TYPE(base_Num2Pwrs[exp & 3]));
+            outVal = NUM_TYPE.mul(outVal, tmpnum);
+        }
+        if ((sign & 0x80) !== 0)
+            outVal._data[0] = outVal._data[0] | NUM_TYPE.SIGN_MASK;
+        outVal.round(dec);
+        return outVal;
+    }
+    static eval_op_log(val1) {
+        if (val1 == null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        if (d > 0.0)
+            resVal = NUM_TYPE.from_double(Math.log(d));
+        else
+            resVal.NUM_ZERO();
+        return resVal;
+    }
+    static eval_op_exp(val1) {
+        let resVal;
+        if (val1 === null)
+            return null;
+        let d = val1.to_double();
+        resVal = NUM_TYPE.from_double(Math.exp(d));
+        return resVal;
+    }
+    static eval_op_abs(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE(val1);
+        resVal.num_abs();
+        return resVal;
+    }
+    static eval_op_sin(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        resVal = NUM_TYPE.from_double(Math.sin(d));
+        return resVal;
+    }
+    static eval_op_cos(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        resVal = NUM_TYPE.from_double(Math.cos(d));
+        return resVal;
+    }
+    static eval_op_tan(val1) {
+        if (val1 == null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        resVal = NUM_TYPE.from_double(Math.tan(d));
+        return resVal;
+    }
+    static eval_op_asin(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        if (d <= 1.0 && d >= -1.0)
+            resVal = NUM_TYPE.from_double(Math.asin(d));
+        else
+            resVal = NUM_TYPE.from_double(0.0);
+        return resVal;
+    }
+    static eval_op_acos(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        if (d <= 1.0 && d >= -1.0)
+            resVal = NUM_TYPE.from_double(Math.acos(d));
+        else
+            resVal = NUM_TYPE.from_double(0.0);
+        return resVal;
+    }
+    static eval_op_atan(val1) {
+        if (val1 === null)
+            return null;
+        let resVal = new NUM_TYPE();
+        let d = val1.to_double();
+        resVal = NUM_TYPE.from_double(Math.atan(d));
+        return resVal;
+    }
+    num_abs() {
+        let l;
+        if (this.NUM_IS_LONG()) {
+            l = this.NUM_LONG();
+            if (l < 0)
+                l = -l;
+            this.NUM_4_LONG(l);
+            return;
+        }
+        this._data[0] &= NUM_TYPE.toSByte(~NUM_TYPE.SIGN_MASK);
+    }
+    static eval_op_rand(val1) {
+        if (val1 === null)
+            return null;
+        let rand_initialized = Randomizer.get_initialized();
+        let rand_mod;
+        let rand_mul;
+        let rand_seed;
+        let tmp_num = new NUM_TYPE();
+        if (!rand_initialized) {
+            Randomizer.set_initialized();
+            rand_mod = new NUM_TYPE();
+            rand_mul = new NUM_TYPE();
+            rand_seed = new NUM_TYPE();
+            rand_mod.num_4_a_std("100000007");
+            rand_mul.num_4_a_std("75000007");
+            rand_seed.num_4_a_std("12345678");
+            Randomizer.set_mod(rand_mod.to_double());
+            Randomizer.set_mul(rand_mul.to_double());
+            Randomizer.set_seed(rand_seed.to_double());
+        }
+        else {
+            rand_mod = NUM_TYPE.from_double(Randomizer.get_mod());
+            rand_mul = NUM_TYPE.from_double(Randomizer.get_mul());
+            rand_seed = NUM_TYPE.from_double(Randomizer.get_seed());
+        }
+        if (!val1.num_is_zero()) {
+            if (val1.num_is_neg())
+                rand_seed.NUM_4_LONG(NUM_TYPE.hash_rand());
+            else
+                rand_seed = new NUM_TYPE(val1);
+        }
+        else {
+            if (rand_seed.num_is_neg()) {
+                tmp_num.NUM_4_LONG(-1);
+                rand_seed = NUM_TYPE.mul(rand_seed, tmp_num);
+            }
+        }
+        rand_seed = NUM_TYPE.mul(rand_seed, rand_mul);
+        rand_seed = NUM_TYPE.mod(rand_seed, rand_mod);
+        tmp_num = NUM_TYPE.div(rand_seed, rand_mod);
+        Randomizer.set_mod(rand_mod.to_double());
+        Randomizer.set_mul(rand_mul.to_double());
+        Randomizer.set_seed(rand_seed.to_double());
+        return tmp_num;
+    }
+    static hash_rand() {
+        return ((new Date().getMilliseconds()) ^ Math.random() * 12345678);
+    }
+}
+export class OperData {
+    NUM_Diff_ = 0;
+    NUM_Exp1_ = 0;
+    NUM_Exp2_ = 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NUM_TYPE.js","sourceRoot":"","sources":["../../../../../../../projects/gui/src/management/data/NUM_TYPE.ts"],"names":[],"mappings":"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","sourcesContent":["import {  Int32, NNumber, NString, NumberStyles, StringBuilder } from '@magic-xpa/mscorelib';\r\nimport { Constants, PICInterface, Randomizer, StorageAttribute, UtilStrByteMode } from '@magic-xpa/utils';\r\nimport { PIC } from '../gui/PIC';\r\nimport { IEnvironment } from '../../env/IEnvironment';\r\nimport { Events } from '../../Events';\r\nimport { GuiEnvironment } from '../../GuiEnvironment';\r\n\r\n///   This class handles a Magic Number the identical way it's represented in Magic.\r\n///   Most of the methods in this class were copied from the C++ sources of Magic,\r\n///   in order to keep the exact logic used in order to implement all the functionality\r\n///   expected, which means that the exact methods names and variables names where used\r\n///   in order to make future debugging more easyer.\r\n///   Notice a long data type that is used in Magic C++ sources, is represented in java\r\n///   by the int data type.\r\n/// </summary>\r\n/// <author>  Alon Bar-Nes\r\n/// </author>\r\n\r\nexport class NUM_TYPE {\r\n  // --------------------------------------------------------------------------\r\n  // Constants\r\n  // --------------------------------------------------------------------------\r\n  static INT_ZERO_HEX: string = \"00000000\";\r\n  static NO_ROOM: number = -1;\r\n  static ZERO_FILL: number = -2;\r\n  static NUM_SIZE: number = 20;\r\n  static NUM_LONG_TYPE: number = -1;\r\n  static EXP_BIAS: number = 64;\r\n  static SIGN_MASK: number = -128;\r\n\r\n  COMMACHAR: string = ',';\r\n  DECIMALCHAR: string = '.';\r\n  private SIGNIFICANT_NUM_SIZE: number = 0;\r\n  private _data: Int8Array = new Int8Array(NUM_TYPE.NUM_SIZE);\r\n\r\n  set Data(value: Int8Array) {\r\n    this._data = value;\r\n  }\r\n\r\n  get Data(): Int8Array {\r\n    return this._data;\r\n  }\r\n\r\n  // --------------------------------------------------------------------------\r\n  // Constructor list\r\n  // --------------------------------------------------------------------------\r\n\r\n  constructor();\r\n  constructor(recordHexStr: string);\r\n  constructor(byteVal: Int8Array, offset: number, length: number);\r\n  constructor(byteVal: Int8Array);\r\n  constructor(decStr: string, pic: PIC, compIdx: number);\r\n  constructor(numFrom: NUM_TYPE);\r\n  constructor(recordHexStrOrByteValOrDecStrOrNumFrom?: any, offsetOrPic?: any, lengthOrCompIdx?: number) {\r\n    if (arguments.length === 0) {\r\n      this.constructor_0();\r\n      return;\r\n    }\r\n    if (arguments.length === 1 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom.constructor === String)) {\r\n      this.constructor_1(recordHexStrOrByteValOrDecStrOrNumFrom);\r\n      return;\r\n    }\r\n    if (arguments.length === 3 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom instanceof Int8Array) && (offsetOrPic === null || offsetOrPic.constructor === Number) && (lengthOrCompIdx === null || lengthOrCompIdx.constructor === Number)) {\r\n      this.constructor_2(recordHexStrOrByteValOrDecStrOrNumFrom, offsetOrPic, lengthOrCompIdx);\r\n      return;\r\n    }\r\n    if (arguments.length === 1 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom instanceof Int8Array)) {\r\n      this.constructor_3(recordHexStrOrByteValOrDecStrOrNumFrom);\r\n      return;\r\n    }\r\n    if (arguments.length === 3 && (recordHexStrOrByteValOrDecStrOrNumFrom === null || recordHexStrOrByteValOrDecStrOrNumFrom.constructor === String) && (offsetOrPic === null || offsetOrPic instanceof PIC) && (lengthOrCompIdx === null || lengthOrCompIdx.constructor === Number)) {\r\n      this.constructor_4(recordHexStrOrByteValOrDecStrOrNumFrom, offsetOrPic, lengthOrCompIdx);\r\n      return;\r\n    }\r\n    this.constructor_5(recordHexStrOrByteValOrDecStrOrNumFrom);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Default constructor. Set value to 0\r\n  /// </summary>\r\n  private constructor_0(): void {\r\n    this.initConst();\r\n    this.NUM_ZERO();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates a Magic Number from a string got from the XML record value. The\r\n  ///   String is 40 characters long in an hexa representation.\r\n  /// </summary>\r\n  /// <param name = \"recordHexStr\">  Magic number in hex format, 40 characters long\r\n  /// </param>\r\n  private constructor_1(recordHexStr: string): void {\r\n    let i: number = 0;\r\n    let twoDigits: string;\r\n    this.initConst();\r\n\r\n    try {\r\n      for (i = 0; i < this.SIGNIFICANT_NUM_SIZE; i = i + 1) {\r\n        twoDigits = recordHexStr.substr( i * 2, 2);\r\n        this._data[i] = NUM_TYPE.toSByte(NNumber.Parse(twoDigits, NumberStyles.HexNumber));\r\n      }\r\n    }\r\n    catch (ex) {\r\n      Events.WriteWarningToLog(ex);\r\n\r\n      this.NUM_ZERO();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates a Magic Number from array of bytes. Used from the expression evaluator\r\n  ///   when a Magic Number value apears within an expression.\r\n  /// </summary>\r\n  /// <param name = \"byteVal\">  Array of bytes representing a Magic Number</param>\r\n  /// <param name = \"offset\">   Index of the first byte </param>\r\n  /// <param name = \"length\">   Number of bytes to use </param>\r\n  private constructor_2(byteVal: Int8Array, offset: number, length: number): void {\r\n    this.constructor_0();\r\n    for (let i: number = 0; i < length; i = i + 1) {\r\n      this._data[i] = byteVal[i + offset];\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates a Magic Number from array of bytes\r\n  /// </summary>\r\n  private constructor_3(byteVal: Int8Array): void {\r\n    this.constructor_2(byteVal, 0, byteVal.length);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates a Magic Number from a decimal for number and its picture\r\n  /// </summary>\r\n  /// <param name = \"decStr\">  The number in a string decimal format </param>\r\n  /// <param name = \"pic\">     The picture format to be used </param>\r\n  private constructor_4(decStr: string, pic: PIC, compIdx: number): void {\r\n    this.constructor_0();\r\n    this.from_a(decStr, pic, compIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Creates a Magic Number from a Magic Number\r\n  /// </summary>\r\n  /// <param name = \"numFrom\">  The source Magic Number </param>\r\n  private constructor_5(numFrom: NUM_TYPE): void {\r\n    this.initConst();\r\n    this._data = new Int8Array(numFrom._data.length);\r\n    for (let _ai: number = 0; _ai < this._data.length; ++_ai)\r\n      this._data[_ai] = numFrom._data[_ai];\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build a decimal string from the number stored in a Magic Number.\r\n  ///   The string is build from the picture provided as a parameter.\r\n  /// </summary>\r\n  /// <param name = \"pic\">The picture to use for building the display string\r\n  /// </param>\r\n  /// <returns> The decimal form of the Magic Number in the specified format\r\n  /// </returns>\r\n  toDisplayValue(pic: PIC): string {\r\n    return this.to_a(pic);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   init constants of the class\r\n  /// </summary>\r\n  private initConst(): void {\r\n    let env: IEnvironment = GuiEnvironment.Environment;\r\n    this.DECIMALCHAR = env.GetDecimal();\r\n    this.COMMACHAR = env.GetThousands();\r\n    this.SIGNIFICANT_NUM_SIZE = env.GetSignificantNumSize();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Build an hexadecimal string from the Magic Number for the data record in\r\n  ///   the XML tag (to be sent to the Magic Server). The length of this string\r\n  ///   will allways be two times the length of the Magic Numbers (in bytes)\r\n  ///   because every byte in the Magic Number will be translated to two\r\n  ///   character hexadecimal string.\r\n  /// </summary>\r\n  /// <returns> the hexadecimal string\r\n  /// </returns>\r\n  toXMLrecord(): string {\r\n    let hexStr: StringBuilder = new StringBuilder(this.SIGNIFICANT_NUM_SIZE * 2);\r\n    let num: number;\r\n\r\n    if (this.NUM_IS_LONG())\r\n      num = 5;\r\n    else\r\n      num = this.SIGNIFICANT_NUM_SIZE;\r\n\r\n    for (let i: number = 0; i < this.SIGNIFICANT_NUM_SIZE; i++) {\r\n      if (i < num)\r\n        hexStr.Append(('0' + (this._data[i] & 0xFF).toString(16)).slice(-2));\r\n      else\r\n        hexStr.Append(\"00\");\r\n    }\r\n\r\n    return hexStr.ToString().toUpperCase();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Transforming a decimal string number to a Magic Number using the format\r\n  ///   provided.\r\n  /// </summary>\r\n  /// <param name = \"Alpha\">  The number is decimal string form\r\n  /// </param>\r\n  /// <param name = \"pic\">    The picture fomat to use for the extracting the number\r\n  /// </param>\r\n  private from_a(Alpha: string, pic: PIC, compIdx: number): void {\r\n    let i: number;\r\n    let idx: number;\r\n    let dec: boolean;\r\n    let decs: number;\r\n    let digit: number;\r\n    let len: number;\r\n    let no_pic: boolean;\r\n    let Pos: number;\r\n    let SType: boolean;\r\n    let SPart: boolean;\r\n    let Signed: number;\r\n    let buf: string;\r\n    let mask: string = \"\";\r\n    let c: string;\r\n    let NgtvPrmt: boolean;\r\n    let Scan: string = \"\";\r\n    let Pbuf: string = \"\";\r\n    let is_negative: boolean;\r\n    let negStr: string;\r\n    let negPref: string;\r\n    let posPref: string;\r\n    let negSuff: string;\r\n    let posSuff: string;\r\n    let specialValNewPolicy: boolean = GuiEnvironment.Environment.GetSpecialValNewPolicy();\r\n\r\n    // Parse the picture format\r\n    no_pic = (pic == null);\r\n    len = 0;\r\n    SType = false;  // PIC_PSTV : true, PIC_NGTV: false\r\n    SPart = false;  // PIC_PREF : true, PIC_SUF : false\r\n\r\n    if (!no_pic) {\r\n      mask = pic.getMask();\r\n      if (!specialValNewPolicy)\r\n        if (Alpha.length > pic.getMaskSize())\r\n          Alpha = Alpha.substr(0, pic.getMaskSize());\r\n      NgtvPrmt = pic.isNegative();\r\n      if (NgtvPrmt) {\r\n        negPref = pic.getNegPref_();\r\n        posPref = pic.getPosPref_();\r\n        negSuff = pic.getNegSuff_();\r\n        posSuff = pic.getPosSuff_();\r\n\r\n        if (negPref.length === posPref.length) {\r\n          if (negPref.length === 0 || negPref === posPref)\r\n            SPart = false;\r\n          // PIC_SUF\r\n          else SPart = true; // PIC_PREF\r\n        }\r\n        else SPart = true; // PIC_PREF\r\n\r\n        if (SPart)\r\n          negStr = negPref;\r\n        else\r\n          negStr = negSuff;\r\n\r\n        if (negStr.length === 0)\r\n          SType = true;\r\n        // PIC_POSITIVE\r\n        else\r\n          SType = false; // PIC_NEGATIVE\r\n\r\n        if (SType)\r\n          Scan = (SPart ? posPref : posSuff);\r\n        else\r\n          Scan = (SPart ? negPref : negSuff);\r\n        len = Scan.length;\r\n      }\r\n    }\r\n    else {\r\n      pic = new PIC(\"\", StorageAttribute.NUMERIC, compIdx);\r\n      NgtvPrmt = false;\r\n    }\r\n\r\n    // Localize variables and flags\r\n    dec = false;\r\n    decs = 0;\r\n    digit = 0;\r\n    Signed = 0;\r\n\r\n    // SpecialValNewPolicy = Y\r\n    // Loop on input string of numbers and match them against the picture mask\r\n    // It may happen that the picture mask is smaller than received number string\r\n    // For example, if the string received is '1234.56' whereas picture is '2.1'\r\n    // then the characters to parse from the input string is '1234.5' i.e. # digits\r\n    // specified in picture before the decimal should be ignored. Parsing should\r\n    // continue till # of digits after decimal point in picture match with those in\r\n    // the input string or the end of the string\r\n    for (idx = 0; idx < Alpha.length; ) {\r\n      // As mentioned above, continue parsing even if mask length as exhausted by checking\r\n      // idx >= pic.mask_size. However, as long as mask length is valid, match the mask\r\n      if (no_pic || (specialValNewPolicy && idx >= pic.getMaskSize())  || mask[idx] === String.fromCharCode(PICInterface.PIC_N)) {\r\n        c = Alpha[idx];\r\n        if (specialValNewPolicy)\r\n        {\r\n          // stop parsing if # of decs already reached\r\n          if (dec && decs === pic.getDec())\r\n          {\r\n            // Finally, stop parsing on matching required no. of decimal digits\r\n            break;\r\n          }\r\n        }\r\n        if (UtilStrByteMode.isDigit(c)) {\r\n          digit++;\r\n          Pbuf += c;\r\n          if (dec)\r\n            decs++;\r\n        }\r\n        else if (c === this.DECIMALCHAR) {\r\n          Pbuf += this.DECIMALCHAR;\r\n          dec = true;\r\n        }\r\n        else if (c !== this.COMMACHAR) {\r\n          if (NgtvPrmt && Signed === 0) {\r\n            Signed = 1;\r\n            for (i = idx, Pos = 0; i <= Alpha.length && Pos < len; i++) {\r\n              if (no_pic || mask[i] === String.fromCharCode(PICInterface.PIC_N)) {\r\n                c = Alpha[i];\r\n                if (c !== Scan[Pos]) {\r\n                  if (c === '-' && !SType)\r\n                    break;\r\n                  if (c === '+' && SType)\r\n                    break;\r\n                  Signed = -1;\r\n                  break;\r\n                }\r\n                Pos++;\r\n              }\r\n            }\r\n            if (Pos > 0 && Pos < len)\r\n              Signed = -1;\r\n          }\r\n          else {\r\n            // QCR # 309623 : If prefix/suffix strings contains digits in it, it is considered as part of data.\r\n            // In order to avoid it skip the prefix / suffix strings while extracting the data part to build NUM_TYPE.\r\n            if (idx === 0) {\r\n              if (pic.getNegPref_().length > 0)\r\n                if (Alpha.startsWith(pic.getNegPref_())) {\r\n                  idx += pic.getNegPref_().length;\r\n                  continue;\r\n                }\r\n              if (pic.getPosPref_().length > 0)\r\n                if (Alpha.startsWith(pic.getPosPref_())) {\r\n                  idx += pic.getPosPref_().length;\r\n                  continue;\r\n                }\r\n            }\r\n            else {\r\n              if (pic.getNegSuff_().length > 0)\r\n                if (Alpha.endsWith(pic.getNegSuff_())) {\r\n                  idx += pic.getNegSuff_().length;\r\n                  continue;\r\n                }\r\n              if (pic.getPosSuff_().length > 0)\r\n                if (Alpha.endsWith(pic.getPosSuff_())) {\r\n                  idx += pic.getPosSuff_().length;\r\n                  continue;\r\n                }\r\n            }\r\n          }\r\n        }\r\n      }\r\n      idx++;\r\n    }\r\n\r\n    if (Signed === 0 && SType)\r\n      Signed = 1;\r\n\r\n    // Return result of decoded digits\r\n    is_negative = (Signed === 1 && !SType) || (Signed !== 1 && SType);\r\n    if (decs > 0 || digit > 9) {\r\n      buf = (is_negative ? '-' : ' ') + Pbuf;\r\n      this.num_4_a_std(buf);\r\n    }\r\n    else\r\n      this.NUM_4_LONG((is_negative ? -1 : 1) * this.a_2_long(Pbuf));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Extracting a non long number from a decimal string number (numbers with\r\n  ///   decimal point, etc...)\r\n  /// </summary>\r\n  /// <param name = \"str\">  The decimal string number\r\n  /// </param>\r\n  num_4_a_std(str: string): void {\r\n    let digstr: string = \"\";\r\n    let diglen: number = 0;\r\n    let wholes: number = 0;\r\n    let decs: number = 0;\r\n    let isDec: boolean = false;\r\n    let isminus: boolean = false;\r\n    let pos: number;\r\n\r\n    for (pos = 0; pos < str.length; pos++) {\r\n      let c: string = str.charAt(pos);\r\n      if (UtilStrByteMode.isDigit(c)) {\r\n        if (diglen > 0 || c !== '0') {\r\n          diglen++;\r\n          digstr = digstr + c;\r\n          if (!isDec)\r\n            wholes++;\r\n        }\r\n        else if (isDec)\r\n          decs = decs + 1;\r\n      }\r\n      else if (c === this.DECIMALCHAR)\r\n        isDec = true;\r\n      else if (c === '-')\r\n        isminus = true;\r\n    }\r\n\r\n    this.NUM_ZERO();\r\n    if (diglen === 0)\r\n      return;\r\n\r\n    if (((wholes + decs) & 1) > 0) {\r\n      this._data[1] = NUM_TYPE.toSByte(digstr.charCodeAt(0) - '0'.charCodeAt(0));\r\n      pos = 1;\r\n    }\r\n    else\r\n      pos = 0;\r\n\r\n    let numptr: number = 1 + pos;\r\n    diglen = Math.min(diglen, (this.SIGNIFICANT_NUM_SIZE - 1) * 2 - pos);\r\n    while (pos < diglen) {\r\n      let digit1: number = NUM_TYPE.toSByte((digstr.charCodeAt(pos++) - '0'.charCodeAt(0)));\r\n      let digit2: number = NUM_TYPE.toSByte(((pos < diglen)\r\n        ? (digstr.charCodeAt(pos++) - '0'.charCodeAt(0))\r\n        : '\\0'.charCodeAt(0)));\r\n      this._data[numptr++] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(digit1) * 10 + NUM_TYPE.toUByte(digit2));\r\n    }\r\n\r\n    if (wholes > 0)\r\n      this._data[0] = NUM_TYPE.toSByte(<number>NUM_TYPE.EXP_BIAS + ((wholes + 1) >> 1));\r\n    else\r\n      this._data[0] = NUM_TYPE.toSByte(<number>NUM_TYPE.EXP_BIAS - (decs >> 1));\r\n\r\n    if (isminus)\r\n      this._data[0] |= NUM_TYPE.SIGN_MASK;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Translating a long value into an internal Magic Number form\r\n  /// </summary>\r\n  /// <param name = \"longVal\">  The number to be kept\r\n  /// </param>\r\n  NUM_4_LONG(longVal: number): void {\r\n    let hexStr: string;\r\n    this.NUM_ZERO();\r\n\r\n    if (longVal !== 0) {\r\n      if (longVal < 0)\r\n        longVal = (0xFFFFFFFF + longVal + 1);\r\n\r\n      hexStr = longVal.toString(16);\r\n      if (longVal > 0)\r\n        hexStr = NUM_TYPE.INT_ZERO_HEX.substr(hexStr.length) + hexStr;\r\n\r\n      this._data[1] = NUM_TYPE.toSByte(parseInt(hexStr.substr(6, (8) - (6)), 16));\r\n      this._data[2] = NUM_TYPE.toSByte(parseInt(hexStr.substr(4, (6) - (4)), 16));\r\n      this._data[3] = NUM_TYPE.toSByte(parseInt(hexStr.substr(2, (4) - (2)), 16));\r\n      this._data[4] = NUM_TYPE.toSByte(parseInt(hexStr.substr(0, (2) - (0)), 16));\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Getting a long value from a decimal string representing a long value\r\n  /// </summary>\r\n  /// <param name = \"str\">  the string representing a long value\r\n  /// </param>\r\n  /// <returns> the long number\r\n  /// </returns>\r\n  a_2_long(str: string): number {\r\n    let n: number = 0;\r\n    for (let pos: number = 0; pos < str.length; pos++) {\r\n      if (UtilStrByteMode.isDigit(str.charAt(pos))) {\r\n        n = n * 10;\r\n        n = n + str.charCodeAt(pos) - '0'.charCodeAt(0);\r\n      }\r\n    }\r\n    return n;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Activating the process of building a decimal string by the format indicated\r\n  /// </summary>\r\n  /// <param name = \"pic\">a numeric picture to use for building the display string\r\n  /// </param>\r\n  to_a(pic: PIC): string {\r\n    return this.to_a_pic(pic);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performs the process of building a decimal string by the picture provided\r\n  /// </summary>\r\n  /// <param name = \"pic\">  the picture class holding the information about the picture\r\n  /// </param>\r\n  /// <returns> the string form of the Magic Number\r\n  /// </returns>\r\n  protected to_a_pic(pic: PIC): string {\r\n    let buf: string[] = new Array<string>(128);\r\n    let remains: number;\r\n    let sign_n: boolean;\r\n    let pref_len: number;\r\n    let suff_len: number;\r\n    let pref_str: String;\r\n    let suff_str: String;\r\n    let str_pos: number;\r\n    let str_len: number;\r\n    let out_pos: number;\r\n    let out_buf: string[];\r\n    let tmp_out_buf: string[];\r\n    let pad: string;\r\n    let left: boolean;\r\n    let pfill: boolean;\r\n    let mask_chars: number;\r\n    let len: number;\r\n    let res: string[];\r\n    let i: number;\r\n    let isOut: boolean;\r\n    let outVal: string[];\r\n\r\n    len = pic.getMaskSize();\r\n\r\n    // Set signs of number\r\n    sign_n = (pic.isNegative() && this.num_is_neg() ? false : true);\r\n\r\n    pref_len = (sign_n ? pic.getPosPref_().length : pic.getNegPref_().length); // pic_sign[PIC_PREF].len;\r\n    suff_len = (sign_n ? pic.getPosSuff_().length : pic.getNegSuff_().length); // pic_sign[PIC_SUFF].len;\r\n\r\n    left = pic.isLeft();\r\n    pfill = pic.padFill();\r\n    mask_chars = pic.getMaskChars();\r\n    outVal = NString.ToCharArray(pic.getMask().substr(0, len));\r\n    out_buf = ((left || (mask_chars > 0)) ? buf : outVal);\r\n    if (left)\r\n    {\r\n      for (i=0; i < out_buf.length; i++ )\r\n        out_buf[i] = (<string>'0'.toLowerCase());\r\n    }\r\n    isOut = ((left || (mask_chars > 0)) ? false : true);\r\n\r\n    // Convert to string\r\n    str_pos = pref_len;\r\n    str_len = len - pref_len - suff_len;\r\n    tmp_out_buf = out_buf.slice(str_pos, out_buf.length);\r\n    if (this.NUM_IS_LONG())\r\n      remains = this.num_l_2_str(this.NUM_LONG(), tmp_out_buf, str_len, pic);\r\n    else\r\n        remains = this.to_str(tmp_out_buf, str_len, pic);\r\n\r\n    for (i = str_pos; i < out_buf.length; i++)\r\n        out_buf[i] = tmp_out_buf[i - str_pos];\r\n    tmp_out_buf = null;\r\n\r\n    if (remains < mask_chars) {\r\n        res = new Array(len);\r\n      for (i = 0; i < len; i++)\r\n        res[i] = (remains === NUM_TYPE.ZERO_FILL ? pic.getZeroPad() : '*');\r\n      return NString.FromChars(res);\r\n    }\r\n\r\n    if (mask_chars > 0) {\r\n      remains -= mask_chars;\r\n      str_pos += mask_chars;\r\n      str_len -= mask_chars;\r\n    }\r\n\r\n    // take care of pad after and before number\r\n    if (pfill) {\r\n      pad = pic.getPad();\r\n      if (left) {\r\n        for (i = 0; i < remains; i++)\r\n          out_buf [str_pos + str_len + i] = pad;\r\n        str_pos += remains;\r\n      }\r\n      else {\r\n        for (i = 0; i < remains; i++)\r\n          out_buf[str_pos + i] = pad;\r\n      }\r\n    }\r\n    else {\r\n      pad = ' ';\r\n      str_pos += remains;\r\n      str_len -= remains;\r\n    }\r\n\r\n    // take care of suffix and prefix\r\n    if (suff_len > 0) {\r\n      suff_str = sign_n ? pic.getPosSuff_() : pic.getNegSuff_();\r\n      if (suff_len === 1)\r\n        out_buf[str_pos + str_len] = suff_str[0];\r\n      else {\r\n        for (i = 0; i < suff_len; i++)\r\n          out_buf[str_pos + str_len + i] = suff_str[i];\r\n      }\r\n      str_len += suff_len;\r\n    }\r\n    if (pref_len > 0) {\r\n      str_pos -= pref_len;\r\n      str_len += pref_len;\r\n      pref_str = sign_n ? pic.getPosPref_() : pic.getNegPref_();\r\n      if (pref_len === 1)\r\n          out_buf[str_pos] = pref_str[0];\r\n      else\r\n        for (i = 0; i < pref_len; i++)\r\n          out_buf[str_pos + i] = pref_str[i];\r\n    }\r\n\r\n    // str_pos now points to beginning of result str\r\n    // take care of final pad after and before number\r\n    if (!pfill) {\r\n      let outBufLen: number = out_buf.length;\r\n\r\n      if (left) {\r\n        for (i = 0; i < remains && (str_pos + str_len + i < outBufLen); i++)\r\n          out_buf[str_pos + str_len + i] = pad;\r\n      }\r\n      else {\r\n        str_pos -= remains;\r\n\r\n        for (i = 0; i < remains && (str_pos + i < outBufLen); i++)\r\n          out_buf[str_pos + i] = pad;\r\n      }\r\n    }\r\n\r\n    // result built, finish\r\n    if (isOut)\r\n      return NString.FromChars(out_buf);\r\n\r\n    // Copy result to output buffer\r\n    if (mask_chars === 0) {\r\n      if (str_pos + len > out_buf.length)\r\n        len = out_buf.length - str_pos;\r\n      return NString.FromChars(out_buf, str_pos,  len);\r\n    }\r\n\r\n    for (out_pos = 0; out_pos < len && str_pos < out_buf.length; out_pos++)\r\n      if (outVal[out_pos] === String.fromCharCode(PICInterface.PIC_N))\r\n        outVal[out_pos] = out_buf[str_pos++];\r\n\r\n    return NString.FromChars(outVal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bulding the basic decimal string number from a long value (without\r\n  ///   the special picture features).\r\n  /// </summary>\r\n  /// <param name = \"num\">  The number to be translated\r\n  /// </param>\r\n  /// <param name = \"str\">  The mask to use for building the string number\r\n  /// </param>\r\n  /// <len>    len   the len to use in the str char array </len>\r\n  /// <param name = \"pic\">  The picture class holding the information about the picture\r\n  /// </param>\r\n  /// <returns> the length of the result string\r\n  /// </returns>\r\n  protected num_l_2_str(num: number, str: string[], len: number, pic: PIC): number {\r\n    let commas: boolean;\r\n    let digits: number;\r\n    let i: number;\r\n    let decs: number;\r\n    let j: number;\r\n\r\n    if (num < 0)\r\n      num = -num;\r\n    commas = pic.withComa();\r\n    decs = Math.min(pic.getDec(), len - 1);\r\n    if (decs > 0)\r\n      len -= (decs + 1);\r\n    i = len;\r\n\r\n    // 26/11/97 Shay Z. Bug #770526 - If The decimal point is the first\r\n    // in the picture's format - assume that the input value is legal !!\r\n    if (num === 0 && !pic.decInFirstPos()) {\r\n      if (pic.zeroFill())\r\n        return (NUM_TYPE.ZERO_FILL);\r\n      if (len === 0)\r\n        return (NUM_TYPE.NO_ROOM);\r\n\r\n      if (i > str.length)\r\n        i = str.length;\r\n\r\n      str[--i] = '0';\r\n    }\r\n\r\n    if (decs > 0) {\r\n        str[len] = this.DECIMALCHAR;\r\n      for (j = 0; j < decs; j++)\r\n        str[len + 1 + j] = '0';\r\n    }\r\n\r\n    digits = 0;\r\n    for (; num > 0; num = Math.floor(num / 10)) {\r\n      i--;\r\n      if (commas) {\r\n        if (digits === 3) {\r\n          if (i < 0)\r\n            return (NUM_TYPE.NO_ROOM);\r\n          digits = 0;\r\n          str[i--] = this.COMMACHAR;\r\n        }\r\n        digits++;\r\n      }\r\n      if (i < 0)\r\n        return (NUM_TYPE.NO_ROOM);\r\n      str[i] = ((num % 10).toString());\r\n    }\r\n\r\n    return i;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bulding the basic decimal string number from a non long value (without\r\n  ///   the special picture features).\r\n  /// </summary>\r\n  /// <param name = \"str\">  The mask to use for building the string number\r\n  /// </param>\r\n  /// <len>    len   the len to use in the str char array </len>\r\n  /// <param name = \"pic\">  The picture class holding the information about the picture\r\n  /// </param>\r\n  /// <returns> the length of the result string\r\n  /// </returns>\r\n  protected to_str(str: string[], len: number, pic: PIC): number {\r\n    let tmp: NUM_TYPE;\r\n    let commas: boolean;\r\n    let digits: number;\r\n    let decpos: number;\r\n    let last: number;\r\n    let first: number;\r\n    let j: number;\r\n    let i: number;\r\n    let decs: number;\r\n    let num_char: number;\r\n\r\n    commas = pic.withComa();\r\n    decs = pic.getDec();\r\n    if (decs >= len)\r\n      decs = len - 1;\r\n\r\n    tmp = new NUM_TYPE(this);\r\n    tmp.round(decs);\r\n    if (tmp.NUM_IS_LONG())\r\n      return tmp.num_l_2_str(tmp.NUM_LONG(), str, len, pic);\r\n\r\n    if (pic.zeroFill() && tmp._data[0] === 0)\r\n      return (NUM_TYPE.ZERO_FILL);\r\n\r\n    i = len - 1;\r\n    digits = 0;\r\n    decpos = ((tmp._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS + 1) * 2;\r\n    last = decpos - 1 + decs;\r\n    first = decpos - 1;\r\n    if (first > 2)\r\n      first = (tmp._data[1] < 10) ? 3 : 2;\r\n\r\n    for (j = last; j >= first; j--) {\r\n      if (i < 0)\r\n        return (NUM_TYPE.NO_ROOM);\r\n\r\n      if (commas && (j < decpos)) {\r\n        if (digits === 3) {\r\n          digits = 0;\r\n          str[i--] = this.COMMACHAR;\r\n        }\r\n        digits++;\r\n      }\r\n\r\n      // JPN:15/08/1996 Yama (JpnID:ZA0815001)\r\n      // When Format=\"N12C\" and num is bigger than 12 digits.\r\n      // MAGIC crushes. Because the var i becomes negative.\r\n      if (i < 0)\r\n        return (NUM_TYPE.NO_ROOM);\r\n\r\n      if ((j < 2) || (j >= this.SIGNIFICANT_NUM_SIZE * 2))\r\n        str[i--] = '0';\r\n      else {\r\n        if (i < 0)\r\n          return (NUM_TYPE.NO_ROOM);\r\n        num_char = tmp._data[j >> 1];\r\n        str[i--] = (((j & 1) !== 0) ? (num_char % 10) : (Math.floor(num_char / 10))).toString();\r\n      }\r\n\r\n      if (j === decpos) {\r\n        if (i < 0)\r\n          return (NUM_TYPE.NO_ROOM);\r\n        str[i--] = this.DECIMALCHAR;\r\n\r\n        // 26/11/97 Shay Z. Bug #770526 - If The decimal point is the first\r\n        // in the picture's format - assume that the input value is legal !\r\n        if (i < 0 && pic.decInFirstPos())\r\n          return (0);\r\n      }\r\n    }\r\n\r\n    return (i + 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing an Add operation on two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static add(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n    let sign1: number;\r\n    let sign2: number;\r\n    let l: number;\r\n    let l1: number;\r\n    let l2: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n    // null values\r\n    if (num1 === null || num2 === null)\r\n      return null;\r\n\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n    let tmpres: NUM_TYPE = new NUM_TYPE();\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    let operData: OperData = new OperData();\r\n    if (num1.NUM_IS_LONG()) {\r\n      if (num2.NUM_IS_LONG()) {\r\n\r\n        l = l1 = num1.NUM_LONG();\r\n        if (l < 0)\r\n          l = -l;\r\n\r\n        if (l < 0x40000000) {\r\n          l = l2 = num2.NUM_LONG();\r\n          if (l < 0)\r\n            l = -l;\r\n          if (l < 0x40000000) {\r\n            l1 += l2;\r\n            res.NUM_4_LONG(l1);\r\n            return res;\r\n          }\r\n        }\r\n        num2.num_4_std_long();\r\n      }\r\n      num1.num_4_std_long();\r\n    }\r\n    else if (num2.NUM_IS_LONG())\r\n      num2.num_4_std_long();\r\n\r\n    sign1 = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    sign2 = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Diff_ = <number>(operData.NUM_Exp1_ - operData.NUM_Exp2_);\r\n\r\n    let cmpval: number = operData.NUM_Diff_;\r\n    if (cmpval === 0) {\r\n      cmpval = NUM_TYPE.toUByte(num1._data[1]) - NUM_TYPE.toUByte(num2._data[1]);\r\n      if (cmpval === 0)\r\n        cmpval = NUM_TYPE.memcmp(num1, 2, num2, 2, SIGNIFICANT_NUM_SIZE - 2);\r\n    }\r\n\r\n    if (cmpval >= 0) {\r\n      if (sign1 === sign2)\r\n        tmpres = NUM_TYPE.add_pos(num1, num2, operData);\r\n      else\r\n        tmpres = NUM_TYPE.sub_pos(num1, num2, operData);\r\n\r\n      if (tmpres._data[0] !== 0)\r\n        tmpres._data[0] = NUM_TYPE.toSByte(tmpres._data[0] | sign1);\r\n    }\r\n    else {\r\n      let exp: number = operData.NUM_Exp1_;\r\n      operData.NUM_Exp1_ = operData.NUM_Exp2_;\r\n      operData.NUM_Exp2_ = exp;\r\n      operData.NUM_Diff_ = -operData.NUM_Diff_;\r\n\r\n      if (sign1 === sign2)\r\n        tmpres = NUM_TYPE.add_pos(num2, num1, operData);\r\n      else\r\n        tmpres = NUM_TYPE.sub_pos(num2, num1, operData);\r\n\r\n      if (tmpres._data[0] !== 0)\r\n        tmpres._data[0] |= sign2;\r\n    }\r\n\r\n    return tmpres;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing a Subtract operation on two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static sub(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n    // null values\r\n    if (num1 === null || num2 === null)\r\n      return null;\r\n\r\n    let tmpres: NUM_TYPE = new NUM_TYPE();\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    let operData: OperData = new OperData();\r\n\r\n    if (num1.NUM_IS_LONG()) {\r\n      if (num2.NUM_IS_LONG()) {\r\n        let l: number;\r\n        let l1: number = l = num1.NUM_LONG();\r\n        if (l < 0)\r\n          l = -l;\r\n        if (l < 0x40000000) {\r\n          let l2: number = l = num2.NUM_LONG();\r\n          if (l < 0)\r\n            l = -l;\r\n          if (l < 0x40000000) {\r\n            l1 -= l2;\r\n            res.NUM_4_LONG(l1);\r\n            return res;\r\n          }\r\n        }\r\n        num2.num_4_std_long();\r\n      }\r\n      num1.num_4_std_long();\r\n    }\r\n    else if (num2.NUM_IS_LONG())\r\n      num2.num_4_std_long();\r\n\r\n    let sign1: number = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    let sign2: number = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Diff_ = <number>(operData.NUM_Exp1_ - operData.NUM_Exp2_);\r\n\r\n    let cmpval: number = operData.NUM_Diff_;\r\n    if (cmpval === 0) {\r\n      cmpval = NUM_TYPE.toUByte(num1._data[1]) - NUM_TYPE.toUByte(num2._data[1]);\r\n      if (cmpval === 0)\r\n        cmpval = NUM_TYPE.memcmp(num1, 2, num2, 2, GuiEnvironment.Environment.GetSignificantNumSize() - 2);\r\n    }\r\n\r\n    if (cmpval >= 0) {\r\n      if (sign1 === sign2)\r\n        tmpres = NUM_TYPE.sub_pos(num1, num2, operData);\r\n      else\r\n        tmpres = NUM_TYPE.add_pos(num1, num2, operData);\r\n\r\n    }\r\n    else {\r\n      let exp: number = operData.NUM_Exp1_;\r\n      operData.NUM_Exp1_ = operData.NUM_Exp2_;\r\n      operData.NUM_Exp2_ = exp;\r\n      operData.NUM_Diff_ = -operData.NUM_Diff_;\r\n      if (sign1 === sign2) {\r\n        tmpres = NUM_TYPE.sub_pos(num2, num1, operData);\r\n        sign1 ^= (NUM_TYPE.SIGN_MASK);\r\n      }\r\n      else\r\n        tmpres = NUM_TYPE.add_pos(num2, num1, operData);\r\n    }\r\n\r\n    if (tmpres._data[0] !== 0)\r\n      tmpres._data[0] |= sign1;\r\n\r\n    return tmpres;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing a Multiply operation on two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static mul(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n\r\n    let fullres: Int8Array = new Int8Array(38);\r\n    let pwr: number;\r\n    let len1: number;\r\n    let len2: number;\r\n    let pos1: number;\r\n    let pos2: number;\r\n    let pos: number;\r\n    let digit1: number;\r\n    let prod: number;\r\n    let carry: number;\r\n    let l: number;\r\n    let l1: number;\r\n    let l2: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n\r\n    // null values\r\n    if (num1 === null || num2 === null)\r\n      return null;\r\n\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    let operData: OperData = new OperData();\r\n    let i: number;\r\n    let tmpByte: number;\r\n\r\n    if (num1.NUM_IS_LONG()) {\r\n      if (num2.NUM_IS_LONG()) {\r\n        l = l1 = num1.NUM_LONG();\r\n        if (l < 0)\r\n          l = -l;\r\n        if (l < 0xB000) {\r\n          l = l2 = num2.NUM_LONG();\r\n          if (l < 0)\r\n            l = -l;\r\n          if (l < 0xB000) {\r\n            l1 = l1 * l2;\r\n            res.NUM_4_LONG(l1);\r\n            return res;\r\n          }\r\n        }\r\n        num2.num_4_std_long();\r\n      }\r\n      num1.num_4_std_long();\r\n    }\r\n    else if (num2.NUM_IS_LONG())\r\n        num2.num_4_std_long();\r\n\r\n    operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    if (operData.NUM_Exp1_ === 0 || operData.NUM_Exp2_ === 0) {\r\n      res.NUM_ZERO();\r\n      return res;\r\n    }\r\n\r\n    for (len1 = SIGNIFICANT_NUM_SIZE - 1;\r\n         num1._data[len1] === 0;\r\n         len1--) {\r\n    }\r\n    for (len2 = SIGNIFICANT_NUM_SIZE - 1;\r\n         num2._data[len2] === 0;\r\n         len2--) {\r\n    }\r\n\r\n    for (i = 0; i < (NUM_TYPE.NUM_SIZE - 1) * 2; i++)\r\n      fullres[i] = 0;\r\n\r\n    pos = 0;\r\n    for (pos1 = len1; pos1 > 0; pos1--) {\r\n      pos = pos1 + len2 - 1;\r\n      digit1 = num1._data[pos1];\r\n      carry = 0;\r\n\r\n      for (pos2 = len2; pos2 > 0; pos2--) {\r\n        prod = NUM_TYPE.toUByte(digit1) * NUM_TYPE.toUByte(num2._data[pos2]) + carry;\r\n        carry = Math.floor(prod / 100);\r\n        fullres[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(fullres[pos]) + prod % 100);\r\n        tmpByte = fullres[pos];\r\n        pos--;\r\n        if (NUM_TYPE.toUByte(tmpByte) >= 100) {\r\n          fullres[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(fullres[pos + 1]) - 100);\r\n          carry++;\r\n        }\r\n      }\r\n      fullres[pos] = NUM_TYPE.toSByte(carry);\r\n    }\r\n\r\n    pwr = NUM_TYPE.toUByte(operData.NUM_Exp1_) - NUM_TYPE.EXP_BIAS + (NUM_TYPE.toUByte(operData.NUM_Exp2_) - NUM_TYPE.EXP_BIAS);\r\n    if (fullres[0] === 0) {\r\n      pos++;\r\n      pwr--;\r\n    }\r\n\r\n    if ((num1._data[0] & NUM_TYPE.SIGN_MASK) === (num2._data[0] & NUM_TYPE.SIGN_MASK))\r\n      res._data[0] = 0;\r\n    else\r\n      res._data[0] = NUM_TYPE.SIGN_MASK;\r\n\r\n    res._data[0] |= NUM_TYPE.toSByte(pwr + NUM_TYPE.EXP_BIAS);\r\n    for (i = 0; i < SIGNIFICANT_NUM_SIZE - 1; i++)\r\n      res._data[1 + i] = fullres[pos + i];\r\n\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing a Mod operation on two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static mod(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n    // null values\r\n    if (num1 === null || num2 === null)\r\n      return null;\r\n\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    if (num2.num_is_zero()) {\r\n      res.NUM_ZERO();\r\n      return res;\r\n    }\r\n\r\n    if (num1.NUM_IS_LONG())\r\n      num1.num_4_std_long();\r\n\r\n    if (num2.NUM_IS_LONG())\r\n      num2.num_4_std_long();\r\n\r\n    res = NUM_TYPE.div(num1, num2);\r\n    res.num_trunc(0);\r\n    res = NUM_TYPE.mul(res, num2);\r\n    res = NUM_TYPE.sub(num1, res);\r\n\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing a Divide operation on two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static div(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n    let dividend: Int8Array = new Int8Array((NUM_TYPE.NUM_SIZE - 1) * 2);\r\n    let divisor: Int8Array = new Int8Array(NUM_TYPE.NUM_SIZE);\r\n    let pwr: number;\r\n    let len1: number;\r\n    let len2: number;\r\n    let pos1: number;\r\n    let pos2: number;\r\n    let pos: number;\r\n    let quot: number;\r\n    let prod: number;\r\n    let carry: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n\r\n    // null values\r\n    if (num1 === null || num2 === null)\r\n      return null;\r\n\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    let operData: OperData = new OperData();\r\n    let i: number;\r\n    let tmpByte: number;\r\n\r\n    if (num1.NUM_IS_LONG())\r\n      num1.num_4_std_long();\r\n    if (num2.NUM_IS_LONG())\r\n      num2.num_4_std_long();\r\n\r\n    operData.NUM_Exp1_ = NUM_TYPE.toSByte(num1._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    operData.NUM_Exp2_ = NUM_TYPE.toSByte(num2._data[0] & ~NUM_TYPE.SIGN_MASK);\r\n    if (operData.NUM_Exp1_ === 0 || operData.NUM_Exp2_ === 0) {\r\n      res.NUM_ZERO();\r\n      return res;\r\n    }\r\n\r\n    for (len1 = SIGNIFICANT_NUM_SIZE - 1;\r\n         num1._data[len1] === 0;\r\n         len1--) {\r\n    }\r\n    for (len2 = SIGNIFICANT_NUM_SIZE - 1;\r\n         num2._data[len2] === 0;\r\n         len2--) {\r\n    }\r\n\r\n    pos = (NUM_TYPE.memcmp(num1, 1, num2, 1, len2) < 0) ? 0 : 1;\r\n    for (i = 0; i < (NUM_TYPE.NUM_SIZE - 1) * 2; i++)\r\n      dividend[i] = 0;\r\n\r\n    for (i = 0; i < len1; i++)\r\n      dividend[pos + i] = num1._data[1 + i];\r\n\r\n    for (i = 0; i < len2; i++)\r\n      divisor[1 + i] = num2._data[1 + i];\r\n\r\n    res.NUM_SET_ZERO();\r\n    pwr = NUM_TYPE.toUByte(operData.NUM_Exp1_) - NUM_TYPE.toUByte(operData.NUM_Exp2_) + pos;\r\n    res._data[0] = NUM_TYPE.toSByte(pwr + NUM_TYPE.EXP_BIAS);\r\n    if ((num1._data[0] & NUM_TYPE.SIGN_MASK) !== (num2._data[0] & NUM_TYPE.SIGN_MASK))\r\n      res._data[0] |= NUM_TYPE.SIGN_MASK;\r\n\r\n    // normalize dividend & divisor\r\n    quot = Math.floor(100 / (NUM_TYPE.toUByte(divisor[1]) + 1));\r\n    if (quot > 1) {\r\n      carry = 0;\r\n      for (pos2 = len2; pos2 > 0; pos2--) {\r\n        prod = quot * NUM_TYPE.toUByte(divisor[pos2]) + carry;\r\n        carry = Math.floor(prod / 100);\r\n        divisor[pos2] = NUM_TYPE.toSByte(prod % 100);\r\n      }\r\n\r\n      carry = 0;\r\n      for (pos1 = len1 + pos - 1; pos1 >= 0; pos1--) {\r\n        prod = quot * NUM_TYPE.toUByte(dividend[pos1]) + carry;\r\n        carry = Math.floor(prod / 100);\r\n        dividend[pos1] = NUM_TYPE.toSByte(prod % 100);\r\n      }\r\n    }\r\n\r\n    // divide dividend by divisor\r\n    for (pos1 = 1; pos1 < SIGNIFICANT_NUM_SIZE; pos1++) {\r\n      quot = NUM_TYPE.toUByte(dividend[pos1 - 1]) * 100 + Math.floor(NUM_TYPE.toUByte(dividend[pos1]) / NUM_TYPE.toUByte(divisor[1]));\r\n      if (quot >= 100)\r\n        quot = 99;\r\n\r\n      if (quot !== 0) {\r\n        // multiply divisor by quotient, and subtract from dividend\r\n        pos = pos1 + len2 - 1;\r\n        carry = 0;\r\n        for (pos2 = len2; pos2 > 0; pos2--) {\r\n          prod = quot * NUM_TYPE.toUByte(divisor[pos2]) + carry;\r\n          carry = Math.floor(prod / 100);\r\n          dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) - prod % 100);\r\n          tmpByte = dividend[pos];\r\n          pos--;\r\n          if (tmpByte < 0) {\r\n            dividend[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos + 1]) + 100);\r\n            carry++;\r\n          }\r\n        }\r\n        dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) - carry);\r\n\r\n        // decrement quotient, and add back divisor to dividend\r\n        while (dividend[pos] < 0) {\r\n          quot--;\r\n          pos = pos1 + len2 - 1;\r\n          for (pos2 = len2; pos2 > 0; pos2--) {\r\n            dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) + NUM_TYPE.toUByte(divisor[pos2]));\r\n            tmpByte = dividend[pos];\r\n            pos--;\r\n            if (NUM_TYPE.toUByte(tmpByte) >= 100) {\r\n              dividend[pos + 1] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos + 1]) - 100);\r\n              dividend[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(dividend[pos]) + 1);\r\n            }\r\n          }\r\n        }\r\n      }\r\n      res._data[pos1] = NUM_TYPE.toSByte(quot);\r\n    }\r\n\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Compare two magic numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  The first number\r\n  /// </param>\r\n  /// <param name = \"num2\">  The second number\r\n  /// </param>\r\n  /// <returns> 0 if num1=num2, 1 if num1>num2 or -1 if num1<num2\r\n  /// </returns>\r\n  static num_cmp(num1: NUM_TYPE, num2: NUM_TYPE): number {\r\n    let sign1: number;\r\n    let sign2: number;\r\n    let cmpval: number;\r\n    let l1: number;\r\n    let l2: number;\r\n    let tmp: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n\r\n    if (num1 == null || num2 == null)\r\n      return Int32.MinValue;\r\n\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n\r\n    if (num1.NUM_IS_LONG()) {\r\n      if (num2.NUM_IS_LONG()) {\r\n        l1 = num1.NUM_LONG();\r\n        l2 = num2.NUM_LONG();\r\n        if (l1 >= 0 && l2 >= 0) {\r\n          tmp = l1 - l2;\r\n          if (tmp === 0)\r\n            return (0);\r\n          if (tmp > 0)\r\n            return (1);\r\n          return (-1);\r\n    }\r\n            num2.num_4_std_long();\r\n          }\r\n        num1.num_4_std_long();\r\n      }\r\n    else if (num2.NUM_IS_LONG())\r\n          num2.num_4_std_long();\r\n\r\n    sign1 = NUM_TYPE.toSByte(num1._data[0] & NUM_TYPE.SIGN_MASK);\r\n    sign2 = NUM_TYPE.toSByte(num2._data[0] & NUM_TYPE.SIGN_MASK);\r\n    cmpval = (sign1 === sign2)\r\n      ? NUM_TYPE.memcmp(num1, 0, num2, 0, SIGNIFICANT_NUM_SIZE)\r\n      : 1;\r\n    if (sign1 !== 0)\r\n      cmpval = -cmpval;\r\n    return (cmpval);\r\n        }\r\n\r\n  /// <summary>\r\n  ///   Check if the given hex string represents a long number.\r\n  /// </summary>\r\n  /// <param name = \"numHexStr\">  The hex string to check.\r\n  /// </param>\r\n  /// <returns> true, if the string represents a 'long' number in NUM_TYPE.\r\n  /// </returns>\r\n  static numHexStrIsLong(numHexStr: string): boolean {\r\n    return numHexStr.substr(0, 2) === \"FF\";\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Zeroes the Magic Number as a long zero\r\n  /// </summary>\r\n  NUM_ZERO(): void {\r\n    this.setZero(true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Zeroes the Magic Number (all bytes will set to 0)\r\n  /// </summary>\r\n  NUM_SET_ZERO(): void {\r\n    this.setZero(false);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Getting indication for the sign of the Magic Number\r\n  /// </summary>\r\n  /// <returns> true in the number is negative, false if positive\r\n  /// </returns>\r\n  num_is_neg(): boolean {\r\n    if (this.NUM_IS_LONG())\r\n      return ((this._data[4] & 0x80) !== 0);\r\n    return ((this._data[0] & NUM_TYPE.SIGN_MASK) !== 0);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Getting indication if the Magic Number is ZERO (all bytes equals to 0)\r\n  /// </summary>\r\n  /// <returns> true in the number is ZERO, false if positive\r\n  /// </returns>\r\n  num_is_zero(): boolean {\r\n    if (this.NUM_IS_LONG())\r\n      return (this.NUM_LONG() === 0);\r\n    return (this._data[0] === 0);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Changing sign of Magic Number\r\n  /// </summary>\r\n  num_neg(): void {\r\n    let l: number;\r\n\r\n    if (this.NUM_IS_LONG()) {\r\n      l = -this.NUM_LONG();\r\n      this.NUM_4_LONG(l);\r\n      return;\r\n    }\r\n    if (this._data[0] !== 0)\r\n      this._data[0] ^= NUM_TYPE.SIGN_MASK;\r\n      }\r\n\r\n  /// <summary>\r\n  ///   Is the number kept in in the NUM_TYPE is a long number?\r\n  /// </summary>\r\n  /// <returns> true in the number is long, false if not\r\n  /// </returns>\r\n  NUM_IS_LONG(): boolean {\r\n    return this._data[0] === NUM_TYPE.NUM_LONG_TYPE;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get the long value from the NUM_TYPE.\r\n  ///   THIS FUNCTION MUST BE WRITTEN DIFERENTLY!\r\n  /// </summary>\r\n  /// <returns> the long number\r\n  /// </returns>\r\n  NUM_LONG(): number {\r\n    if (this._data[1] === 0 && this._data[2] === 0 && this._data[3] === 0 && this._data[4] === -128)\r\n      return Int32.MinValue;\r\n\r\n    let dataview = new DataView(this._data.buffer);\r\n    return dataview.getInt32(1, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Rounds the NUM_TYPE number\r\n  /// </summary>\r\n  /// <param name = \"decs\">  number of digits after to decimal point to round to\r\n  /// </param>\r\n  round(decs: number): void {\r\n\r\n    let addval: NUM_TYPE;\r\n\r\n    if (this.NUM_IS_LONG())\r\n      return;\r\n\r\n    addval = new NUM_TYPE();\r\n    addval._data[0] = NUM_TYPE.toSByte((this._data[0] & NUM_TYPE.SIGN_MASK) | (NUM_TYPE.EXP_BIAS - (decs >> 1)));\r\n    addval._data[1] = NUM_TYPE.toSByte((decs & 1) !== 0 ? 5 : 50);\r\n\r\n    let temp: NUM_TYPE = NUM_TYPE.add(this, addval);\r\n    this._data = new Int8Array(temp._data.length);\r\n\r\n    this._data = temp._data;\r\n      this.num_trunc(decs);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Returns a numeric expression, rounded to the specified number of decimal places\r\n  /// </summary>\r\n  /// <param name = \"whole\">the number of decimal places to which the numeric expression is rounded\r\n  /// </param>\r\n  dbRound(whole: number): void {\r\n    let addval: NUM_TYPE;\r\n    let pwr: number;\r\n    let num_diff: number;\r\n    let i: number;\r\n\r\n    if (this.NUM_IS_LONG())\r\n      return;\r\n\r\n    // Add 5 (in the corresponding to whole position)\r\n    addval = new NUM_TYPE();\r\n    addval._data[0] = NUM_TYPE.toSByte((this._data[0] & NUM_TYPE.SIGN_MASK) | (NUM_TYPE.EXP_BIAS + ((whole + 1) >> 1)));\r\n    addval._data[1] = NUM_TYPE.toSByte(((whole & 1) !== 0) ? 5 : 50);\r\n\r\n    let temp: NUM_TYPE = NUM_TYPE.add(this, addval);\r\n    this._data = new Int8Array(temp._data.length);\r\n\r\n      for (let _ai: number = 0; _ai < this._data.length; ++_ai)\r\n      this._data[_ai] = temp._data[_ai];\r\n\r\n    // Put 0 in the end of the number\r\n    pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;\r\n\r\n    if ((num_diff = pwr - ((whole + 1) >> 1)) >= 0) {\r\n      if ((whole & 1) !== 0) {\r\n        this._data[1 + num_diff] = NUM_TYPE.toSByte(this._data[1 + num_diff] - this._data[1 + num_diff] % 10);\r\n        num_diff++;\r\n        }\r\n      for (i = 0;\r\n           i < this.SIGNIFICANT_NUM_SIZE - (1 + num_diff);\r\n           i++)\r\n        this._data[1 + num_diff + i] = 0;\r\n        }\r\n    else\r\n        this.NUM_SET_ZERO();\r\n      }\r\n\r\n  /// <summary>\r\n  ///   Truncates the NUM_TYPE number\r\n  /// </summary>\r\n  /// <param name = \"decs\">  number of digits after to decimal point to have\r\n  /// </param>\r\n  num_trunc(decs: number): void {\r\n    let pwr: number;\r\n    let num_diff: number;\r\n    let i: number;\r\n\r\n    if (this.NUM_IS_LONG())\r\n      return;\r\n\r\n    pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;\r\n    if ((num_diff = this.SIGNIFICANT_NUM_SIZE - 1 - pwr - ((decs + 1) >> 1)) < 0)\r\n      return;\r\n    if ((num_diff < this.SIGNIFICANT_NUM_SIZE - 1) && ((decs & 1) !== 0)) {\r\n      this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] =\r\n        NUM_TYPE.toSByte(this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] - this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] % 10);\r\n      if (this._data[this.SIGNIFICANT_NUM_SIZE - 1 - num_diff] === 0)\r\n        num_diff++;\r\n          }\r\n    if (num_diff >= this.SIGNIFICANT_NUM_SIZE - 1) {\r\n          this.NUM_ZERO();\r\n      return;\r\n        }\r\n    for (i = 0;\r\n         i < num_diff;\r\n         i++)\r\n      this._data[this.SIGNIFICANT_NUM_SIZE - num_diff + i] = 0;\r\n          }\r\n\r\n  /// <summary>\r\n  ///   Converts a Magic number from std long\r\n  /// </summary>\r\n  /// <param name = \"num\">  The number to be translated\r\n  /// </param>\r\n  num_4_std_long(): void {\r\n    let slong: number;\r\n\r\n    slong = this.NUM_LONG();\r\n    if (slong >= 0)\r\n      this.num_4_ulong(slong);\r\n    else {\r\n      this.num_4_ulong(-slong);\r\n      this._data[0] |= NUM_TYPE.SIGN_MASK;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Converts a Magic number from ulong\r\n  /// </summary>\r\n  /// <param name = \"num\">  The number to be translated\r\n  /// </param>\r\n  num_4_ulong(data: number): void {\r\n    let pwr: number;\r\n    let pos: number;\r\n    let i: number;\r\n\r\n    this.NUM_SET_ZERO();\r\n    pos = pwr = 5;\r\n    while (data > 0) {\r\n      this._data[pos--] = NUM_TYPE.toSByte(data % 100);\r\n      data = Math.floor(data / 100);\r\n    }\r\n    if (pos < pwr) {\r\n      if (pos > 0) {\r\n        for (i = 0; i < pwr - pos; i++)\r\n          this._data[1 + i] = this._data[1 + pos + i];\r\n        for (i = 0; i < pos; i++)\r\n          this._data[pwr - pos + 1 + i] = 0;\r\n        }\r\n      this._data[0] = NUM_TYPE.toSByte(pwr - pos + NUM_TYPE.EXP_BIAS);\r\n        }\r\n      }\r\n\r\n  /// <summary>\r\n  ///   Get the long value from a Magic Number\r\n  /// </summary>\r\n  /// <returns> the long value of the number\r\n  /// </returns>\r\n  NUM_2_LONG(): number {\r\n    if (this.NUM_IS_LONG())\r\n      return this.NUM_LONG();\r\n    else\r\n      return this.num_2_long();\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Get the Ulong value from a Magic Number\r\n  /// </summary>\r\n  /// <returns> the long value of the number\r\n  /// </returns>\r\n  NUM_2_ULONG(): number {\r\n    if (this.NUM_IS_LONG())\r\n      return this.NUM_LONG();\r\n    else\r\n      return this.num_2_ulong();\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Get the long value from a non long Magic Number\r\n  /// </summary>\r\n  /// <returns> the long value of the number\r\n  /// </returns>\r\n  num_2_long(): number {\r\n    let slong: number;\r\n    let sign: number;\r\n\r\n    sign = this._data[0] & NUM_TYPE.SIGN_MASK;\r\n    this._data[0] &= NUM_TYPE.toSByte(~NUM_TYPE.SIGN_MASK);\r\n    if (sign !== 0) {\r\n      if (NUM_TYPE.memcmp(this, 0, NUM_TYPE.MinLONG(), 0, this.SIGNIFICANT_NUM_SIZE) > 0)\r\n        return 0;\r\n      }\r\n    else {\r\n      if (NUM_TYPE.memcmp(this, 0, NUM_TYPE.MaxLONG(), 0, this.SIGNIFICANT_NUM_SIZE) > 0)\r\n        return 0;\r\n      }\r\n    slong = this.num_2_ulong();\r\n    if (sign !== 0) {\r\n      slong = -slong;\r\n      this._data[0] |= NUM_TYPE.toSByte(sign);\r\n    }\r\n    return (slong);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Get the ulong value from a non long Magic Number\r\n  /// </summary>\r\n  /// <returns> the ulong value of the number\r\n  /// </returns>\r\n  num_2_ulong(): number {\r\n    let val: number;\r\n    let pwr: number;\r\n    let pos: number;\r\n    let last: boolean;\r\n\r\n    pwr = this._data[0] - NUM_TYPE.EXP_BIAS;\r\n    if (pwr > 5)\r\n      return (0);\r\n    last = (pwr === 5);\r\n    if (last)\r\n      pwr = 4;\r\n\r\n    val = 0;\r\n    for (pos = 1; pos <= pwr; pos++)\r\n      val = val * 100 + NUM_TYPE.toUByte(this._data[pos]);\r\n\r\n    if (last)\r\n      if (val <= Math.floor((0xFFFFFFFF - NUM_TYPE.toUByte(this._data[5])) / 100))\r\n        val = val * 100 + NUM_TYPE.toUByte(this._data[5]);\r\n      else\r\n        val = 0;\r\n    return (val);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Perform the actuall add operation\r\n  /// </summary>\r\n  /// <param name = \"num1\">      The first number\r\n  /// </param>\r\n  /// <param name = \"num2\">      The second number\r\n  /// </param>\r\n  /// <param name = \"operData\">  Information for performing the operation\r\n  /// </param>\r\n  /// <returns> The two numbers added\r\n  /// </returns>\r\n  static add_pos(num1: NUM_TYPE, num2: NUM_TYPE, operData: OperData): NUM_TYPE {\r\n    let len1: number;\r\n    let len2: number;\r\n    let len: number;\r\n    let pos: number;\r\n    let num1ptr: number;\r\n    let resptr: number;\r\n    let i: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n\r\n    // null values\r\n    if (num1 == null || num2 == null)\r\n      return null;\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n\r\n    if (operData.NUM_Exp2_ === 0 || (operData.NUM_Diff_ >= SIGNIFICANT_NUM_SIZE - 1)) {\r\n      res = new NUM_TYPE(num1);\r\n      res._data[0] = operData.NUM_Exp1_;\r\n      return res;\r\n    }\r\n\r\n    len1 = 1;\r\n    for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {\r\n      if (num1.SHRT_IS_ZERO(i))\r\n        continue;\r\n    else {\r\n        len1 = i + 1;\r\n            break;\r\n          }\r\n        }\r\n\r\n    if (num1._data[len1] === 0)\r\n      len1--;\r\n\r\n    len2 = 1;\r\n    for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {\r\n      if (num2.SHRT_IS_ZERO(i))\r\n        continue;\r\n      else {\r\n        len2 = i + 1;\r\n            break;\r\n          }\r\n        }\r\n\r\n    if (num2._data[len2] === 0)\r\n      len2--;\r\n\r\n    if ((len = Math.max(len1, len2 + operData.NUM_Diff_)) > SIGNIFICANT_NUM_SIZE - 1)\r\n      len = SIGNIFICANT_NUM_SIZE - 1;\r\n\r\n    res.NUM_SET_ZERO();\r\n    num1ptr = operData.NUM_Diff_;\r\n    resptr = operData.NUM_Diff_;\r\n    for (pos = len - operData.NUM_Diff_; pos > 0; pos--) {\r\n      res._data[resptr + pos] =\r\n        NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + NUM_TYPE.toUByte(num1._data[num1ptr + pos]) + NUM_TYPE.toUByte(num2._data[pos]));\r\n      if (NUM_TYPE.toUByte(res._data[resptr + pos]) >= 100) {\r\n        res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) - 100);\r\n        res._data[resptr + pos - 1] = 1;\r\n        }\r\n        }\r\n    for (pos = operData.NUM_Diff_; pos > 0; pos--) {\r\n      res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + NUM_TYPE.toUByte(num1._data[pos]));\r\n      if (NUM_TYPE.toUByte(res._data[pos]) >= 100) {\r\n        res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) - 100);\r\n        res._data[pos - 1] = 1;\r\n          }\r\n        }\r\n    if (res._data[0] !== 0) {\r\n      for (pos = Math.min(len, SIGNIFICANT_NUM_SIZE - 2); pos >= 0; pos--)\r\n        res._data[pos + 1] = res._data[pos];\r\n      operData.NUM_Exp1_++;\r\n          }\r\n    res._data[0] = operData.NUM_Exp1_;\r\n\r\n    return res;\r\n        }\r\n\r\n  /// <summary>\r\n  ///   Perform the actuall sub operation\r\n  /// </summary>\r\n  /// <param name = \"num1\">      The first number\r\n  /// </param>\r\n  /// <param name = \"num2\">      The second number\r\n  /// </param>\r\n  /// <param name = \"operData\">  Information for performing the operation\r\n  /// </param>\r\n  /// <returns> The result of the subtraction operation\r\n  /// </returns>\r\n  static sub_pos(num1: NUM_TYPE, num2: NUM_TYPE, operData: OperData): NUM_TYPE {\r\n    let len1: number;\r\n    let len2: number;\r\n    let len: number;\r\n    let pos: number;\r\n    let num1ptr: number;\r\n    let resptr: number;\r\n    let i: number;\r\n    let SIGNIFICANT_NUM_SIZE: number;\r\n\r\n    // null values\r\n    if (num1 == null || num2 == null)\r\n      return null;\r\n\r\n    SIGNIFICANT_NUM_SIZE = GuiEnvironment.Environment.GetSignificantNumSize();\r\n\r\n    let res: NUM_TYPE = new NUM_TYPE();\r\n    let j: number;\r\n\r\n    if (operData.NUM_Exp2_ === 0 || (operData.NUM_Diff_ >= SIGNIFICANT_NUM_SIZE - 1)) {\r\n      res = new NUM_TYPE(num1);\r\n      res._data[0] = operData.NUM_Exp1_;\r\n      return res;\r\n    }\r\n\r\n    len1 = 1;\r\n    for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {\r\n      if (num1.SHRT_IS_ZERO(i))\r\n        continue;\r\n    else {\r\n        len1 = i + 1;\r\n            break;\r\n          }\r\n        }\r\n\r\n    if (num1._data[len1] === 0)\r\n      len1--;\r\n\r\n    len2 = 1;\r\n    for (i = SIGNIFICANT_NUM_SIZE - 2; i > 0; i -= 2) {\r\n      if (num2.SHRT_IS_ZERO(i))\r\n        continue;\r\n      else {\r\n        len2 = i + 1;\r\n            break;\r\n          }\r\n        }\r\n\r\n    if (num2._data[len2] === 0)\r\n      len2--;\r\n\r\n    if ((len = Math.max(len1, len2 + operData.NUM_Diff_)) > SIGNIFICANT_NUM_SIZE - 1)\r\n      len = SIGNIFICANT_NUM_SIZE - 1;\r\n\r\n    res.NUM_SET_ZERO();\r\n    num1ptr = operData.NUM_Diff_;\r\n    resptr = operData.NUM_Diff_;\r\n    for (pos = len - operData.NUM_Diff_; pos > 0; pos--) {\r\n\r\n      res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + NUM_TYPE.toUByte(num1._data[num1ptr + pos]) - NUM_TYPE.toUByte(num2._data[pos]));\r\n      if (res._data[resptr + pos] < 0) {\r\n        res._data[resptr + pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[resptr + pos]) + 100);\r\n        res._data[resptr + pos - 1] = NUM_TYPE.toSByte(0xFF); // 255\r\n        }\r\n            }\r\n    for (pos = operData.NUM_Diff_; pos > 0; pos--) {\r\n      res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + NUM_TYPE.toUByte(num1._data[pos]));\r\n      if (res._data[pos] < 0) {\r\n        res._data[pos] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(res._data[pos]) + 100);\r\n        res._data[pos - 1] = NUM_TYPE.toSByte(0xFF); // 255\r\n            }\r\n          }\r\n    while ((++pos <= len) && res._data[pos] === 0) {\r\n        }\r\n    if (pos <= len) {\r\n      operData.NUM_Diff_ = pos - 1;\r\n      if (operData.NUM_Diff_ > 0) {\r\n        for (j = 0; j < len - operData.NUM_Diff_; j++)\r\n          res._data[1 + j] = res._data[pos + j];\r\n        for (j = 0; j < operData.NUM_Diff_; j++)\r\n          res._data[len - operData.NUM_Diff_ + 1 + j] = 0;\r\n      }\r\n      res._data[0] = NUM_TYPE.toSByte(NUM_TYPE.toUByte(operData.NUM_Exp1_) - operData.NUM_Diff_);\r\n    }\r\n\r\n    return res;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Perform the actual  FIX operation with whole part of the number\r\n  /// </summary>\r\n  /// <param name = \"wholes\">number of needed whole digits\r\n  /// </param>\r\n  num_fix(wholes: number): void {\r\n    let pwr: number;\r\n    let num_diff: number;\r\n\r\n    if (this.NUM_IS_LONG())\r\n      this.num_4_std_long();\r\n    pwr = (this._data[0] & ~NUM_TYPE.SIGN_MASK) - NUM_TYPE.EXP_BIAS;\r\n\r\n    if ((num_diff = pwr - ((wholes + 1) >> 1)) < 0)\r\n      return;\r\n    if (num_diff < this.SIGNIFICANT_NUM_SIZE - 1) {\r\n      if ((wholes & 1) === 1)\r\n        this._data[1 + num_diff] = NUM_TYPE.toSByte(this._data[1 + num_diff] % 10);\r\n      while ((num_diff < this.SIGNIFICANT_NUM_SIZE - 1) && this._data[1 + num_diff] === 0)\r\n        num_diff++;\r\n      }\r\n    if (num_diff >= this.SIGNIFICANT_NUM_SIZE - 1) {\r\n        this.NUM_ZERO();\r\n      return;\r\n      }\r\n    if (num_diff > 0) {\r\n      let i: number;\r\n      for (i = 0; i < this.SIGNIFICANT_NUM_SIZE - 1 - num_diff; i++)\r\n        this._data[1 + i] = this._data[1 + num_diff + i];\r\n\r\n      for (i = 0; i < num_diff; i++)\r\n        this._data[this.SIGNIFICANT_NUM_SIZE - num_diff + i] = 0;\r\n      this._data[0] = NUM_TYPE.toSByte(this._data[0] - NUM_TYPE.toSByte(num_diff));\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if byte on specific position is zero or 0xFF\r\n  /// </summary>\r\n  /// <param name = \"position\">in NUM to be checked\r\n  /// </param>\r\n  /// <returns> is the byte zero\r\n  /// </returns>\r\n  SHRT_IS_ZERO(pos: number): boolean {\r\n    return this._data[pos] === 0 && this._data[pos + 1] === 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Zero a Magic Number. If the number should contain a long zero, the first\r\n  ///   byte is set to NUM_LONG_TYPE.\r\n  /// </summary>\r\n  /// <param name = \"asLong\">  set the Magic Number to contain a long zero value\r\n  /// </param>\r\n  private setZero(asLong: boolean): void {\r\n    let i: number;\r\n\r\n    for (i = 0; i < NUM_TYPE.NUM_SIZE; i++)\r\n      this._data[i] = 0;\r\n\r\n    if (asLong)\r\n      this._data[0] = NUM_TYPE.NUM_LONG_TYPE;\r\n    }\r\n\r\n  /// <summary>\r\n  ///   Compare two Magic Numbers\r\n  /// </summary>\r\n  /// <param name = \"num1\">  The first number\r\n  /// </param>\r\n  /// <param name = \"pos1\">  The position of num1 to compare from\r\n  /// </param>\r\n  /// <param name = \"num2\">  The second number\r\n  /// </param>\r\n  /// <param name = \"pos3\">  The position of num2 to compare from\r\n  /// </param>\r\n  /// <returns> 0 if identical, 1 if num1>num2, -1 if num1<num2\r\n  /// </returns>\r\n  private static memcmp(num1: NUM_TYPE, pos1: number, num2: NUM_TYPE, pos2: number, len: number): number {\r\n    let i: number = 0;\r\n\r\n    while (i < len && num1._data[pos1] === num2._data[pos2] && pos1 < NUM_TYPE.NUM_SIZE && pos2 < NUM_TYPE.NUM_SIZE) {\r\n      i++;\r\n      pos1++;\r\n      pos2++;\r\n    }\r\n\r\n    if (i === len)\r\n      return 0;\r\n    else if (this.toUByte(num1._data[pos1]) < this.toUByte(num2._data[pos2]))\r\n      return -1;\r\n    else\r\n      return 1;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get a unsigned value from a byte\r\n  /// </summary>\r\n  /// <param name = \"byteVal\">  A signed byte value\r\n  /// </param>\r\n  /// <returns> the unsigned value of the byte\r\n  /// </returns>\r\n  static toUByte(byteVal: number): number {\r\n    let val: number = byteVal;\r\n\r\n    if (byteVal < 0)\r\n      val = 256 + byteVal;\r\n\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get a signed byte value from a unsigned val\r\n  /// </summary>\r\n  /// <param name = \"signedVal\">  An unsigned byte value (as an integer)\r\n  /// </param>\r\n  /// <returns> the signed value as a byte\r\n  /// </returns>\r\n  static toSByte(unsignedVal: number): number {\r\n    let val: number = 0;\r\n\r\n    if (unsignedVal > Constants.SByteMaxValue)\r\n      val = (unsignedVal - 256);\r\n    else\r\n      val = unsignedVal;\r\n\r\n    return val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get the maximum long number in NUM_TYPE std format\r\n  /// </summary>\r\n  static MaxLONG(): NUM_TYPE {\r\n    let nUM_TYPE: NUM_TYPE = new NUM_TYPE();\r\n    nUM_TYPE._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5);\r\n    nUM_TYPE._data[1] = 21;\r\n    nUM_TYPE._data[2] = 47;\r\n    nUM_TYPE._data[3] = 48;\r\n    nUM_TYPE._data[4] = 36;\r\n    nUM_TYPE._data[5] = 47;\r\n    return nUM_TYPE;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get the minimum long number in NUM_TYPE std format\r\n  /// </summary>\r\n  static MinLONG(): NUM_TYPE {\r\n    let num: NUM_TYPE = new NUM_TYPE();\r\n    num._data[0] = NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5);\r\n    num._data[1] = 21;\r\n    num._data[2] = 47;\r\n    num._data[3] = 48;\r\n    num._data[4] = 36;\r\n    num._data[5] = 48;\r\n    return num;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get double number from Magic NUM_TYPE\r\n  /// </summary>\r\n  to_double(): number {\r\n    return this.storage_mg_2_float(8); // Length of double is 8 byte\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get double number from Magic NUM_TYPE\r\n  /// </summary>\r\n  /// <param name = \"len\">of byte of needed number - USE 8\r\n  /// </param>\r\n  private storage_mg_2_float(len: number): number {\r\n    let sign_pos: number;\r\n    let sign: number;\r\n    let compnum: NUM_TYPE = new NUM_TYPE();\r\n    let tmpnum: NUM_TYPE = new NUM_TYPE();\r\n    let divnum: NUM_TYPE = new NUM_TYPE();\r\n    let pwr: number;\r\n    let bits: number;\r\n    let exp: number;\r\n    let long1: number = 0;\r\n    let long2: number = 0;\r\n    let fltOut: number = 0;\r\n    let cout: Int8Array = new Int8Array([0, 0, 0, 0, 0, 0, 0, 0]);\r\n    let Num2Pwr23_: Int8Array = new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 8, 38, 86, 8]);\r\n    let Num2Pwr52_: Int8Array = new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]);\r\n    let base_Num16Pwrs: Int8Array[] = [\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 2, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 40, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 3), 6, 55, 36]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 1, 4, 85, 76]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 16, 77, 72, 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 2, 68, 43, 54, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 42, 94, 96, 72, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 6), 6, 87, 19, 47, 67, 36]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 1, 9, 95, 11, 62, 77, 76]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 17, 59, 21, 86, 4, 44, 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 2, 81, 47, 49, 76, 71, 6, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 9), 7, 20, 57, 59, 40, 37, 92, 79, 36])\r\n    ];\r\n\r\n    let base_Num2Pwrs: Int8Array[] = [\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 2]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 4]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 8])\r\n      ];\r\n\r\n    if (this.NUM_IS_LONG())\r\n      this.num_4_std_long();\r\n    if (this._data[0] === 0)\r\n      return 0;\r\n    sign = NUM_TYPE.toSByte(this._data[0] & NUM_TYPE.SIGN_MASK);\r\n    this._data[0] = NUM_TYPE.toSByte(this._data[0] & <number>(~NUM_TYPE.SIGN_MASK));\r\n    if (len === 4) {\r\n      bits = 24;\r\n      compnum = new NUM_TYPE(Num2Pwr23_);\r\n    }\r\n    else {\r\n      bits = 53;\r\n      compnum = new NUM_TYPE(Num2Pwr52_);\r\n    }\r\n    pwr = (this._data[0] - NUM_TYPE.EXP_BIAS) << 1;\r\n    if (pwr < 0)\r\n      exp = pwr * 3 + Math.floor((pwr + 1) / 3);\r\n    else exp = pwr * 3 + Math.floor((pwr + 2) / 3);\r\n    pwr = bits - exp;\r\n    if (pwr < 0) {\r\n      pwr = -pwr;\r\n      tmpnum = NUM_TYPE.div(this, new NUM_TYPE(base_Num16Pwrs[pwr >> 2]));\r\n      tmpnum = NUM_TYPE.div(tmpnum, new NUM_TYPE(base_Num2Pwrs[pwr & 3]));\r\n    }\r\n    else {\r\n      tmpnum = this;\r\n      while (pwr >= 60) {\r\n        tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[14]));\r\n        pwr -= 56;\r\n      }\r\n      tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[pwr >> 2]));\r\n      tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num2Pwrs[pwr & 3]));\r\n    }\r\n    while (NUM_TYPE.num_cmp(tmpnum, compnum) < 0) {\r\n      exp--;\r\n      tmpnum = NUM_TYPE.add(tmpnum, tmpnum);\r\n    }\r\n    if (len === 4) {\r\n      long1 = tmpnum.num_2_ulong();\r\n    }\r\n    else {\r\n      divnum = NUM_TYPE.div(tmpnum, new NUM_TYPE(base_Num16Pwrs[8]));\r\n      divnum.num_trunc(0);\r\n      long1 = divnum.num_2_ulong();\r\n      divnum = NUM_TYPE.mul(divnum, new NUM_TYPE(base_Num16Pwrs[8]));\r\n      divnum = NUM_TYPE.sub(tmpnum, divnum);\r\n      long2 = divnum.num_2_ulong();\r\n    }\r\n    sign_pos = len - 1;\r\n    if (len === 4) {\r\n      exp += 126;\r\n      cout[3] = NUM_TYPE.toSByte(exp >> 1);\r\n      cout[2] = NUM_TYPE.toSByte((this.LO_CHAR(this.HI_SHRT(long1)) & 0x7F) | ((exp & 0x01) << 7));\r\n      cout[1] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long1)));\r\n      cout[0] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long1)));\r\n    }\r\n    else {\r\n      exp += 1022;\r\n      cout[7] = NUM_TYPE.toSByte(exp >> 4);\r\n\r\n      cout[6] = NUM_TYPE.toSByte((this.LO_CHAR(this.HI_SHRT(long1)) & 0x0F) | ((exp & 0x0F) << 4));\r\n\r\n      cout[5] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long1)));\r\n\r\n      cout[4] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long1)));\r\n      cout[3] = NUM_TYPE.toSByte(this.HI_CHAR(this.HI_SHRT(long2)));\r\n      cout[2] = NUM_TYPE.toSByte(this.LO_CHAR(this.HI_SHRT(long2)));\r\n      cout[1] = NUM_TYPE.toSByte(this.HI_CHAR(this.LO_SHRT(long2)));\r\n      cout[0] = NUM_TYPE.toSByte(this.LO_CHAR(this.LO_SHRT(long2)));\r\n    }\r\n    if (sign !== 0) {\r\n      cout[sign_pos] |= NUM_TYPE.SIGN_MASK;\r\n      this._data[0] |= NUM_TYPE.SIGN_MASK;\r\n    }\r\n    fltOut = this.sbyteArr_2_Double(cout);\r\n    return fltOut;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask : Leave last byte in number\r\n  /// </summary>\r\n  private LO_CHAR(n: number): number {\r\n    return n & 255;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask : Leave byte before last\r\n  /// </summary>\r\n  private HI_CHAR(n: number): number {\r\n    return (n & 65280) >> 8;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask : Leave 2 last bytes\r\n  /// </summary>\r\n  private LO_SHRT(n: number): number {\r\n    return <number>(n & 65535);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask\r\n  /// </summary>\r\n  private HI_SHRT(n: number): number {\r\n    return <number>((n & -65536) >> 16);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask\r\n  /// </summary>\r\n  private static MK_SHRT(c1: number, c2: number): number {\r\n    let strInt: string = (c1 << 8 | c2).toString();\r\n    return NNumber.Parse(strInt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Bit_Wise mask\r\n  /// </summary>\r\n  private static MK_LONG(s1: number, s2: number): number {\r\n    let l1: number = <number>s1;\r\n    let l2: number = <number>s2;\r\n    let strLng: string = (l1 << 16 | l2).toString();\r\n    return NNumber.Parse(strLng);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the double from array of bytes\r\n  /// </summary>\r\n  /// <param name = \"array\">of bytes, inner representation of the double\r\n  /// </param>\r\n  /// <returns> double\r\n  /// </returns>\r\n  private sbyteArr_2_Double(array: Int8Array): number {\r\n    let dataview = new DataView(array.buffer);\r\n    return dataview.getFloat64(0, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get byte array for double (8 bytes in Java)\r\n  /// </summary>\r\n  /// <param name = \"double\">to get its byte representation\r\n  /// </param>\r\n  /// <returns> byte array\r\n  /// </returns>\r\n  private static double_2_sbyteArray(d: number): Int8Array {\r\n    let buffer = new ArrayBuffer(8);\r\n    let dataview = new DataView(buffer);\r\n    dataview.setFloat64(0, d, true);\r\n    return (new Int8Array(dataview.buffer));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Performing an Power operation on two magic numbers Val1^Val2\r\n  /// </summary>\r\n  /// <param name = \"num1\">  the first number - number\r\n  /// </param>\r\n  /// <param name = \"num2\">  the first number - power\r\n  /// </param>\r\n  /// <returns> the result\r\n  /// </returns>\r\n  static eval_op_pwr(num1: NUM_TYPE, num2: NUM_TYPE): NUM_TYPE {\r\n    let d0: number;\r\n    let d1: number;\r\n\r\n    // null values\r\n    if (num1 == null || num2 == null)\r\n      return null;\r\n\r\n    // If second operator is an integer (which is so in most of the cases)\r\n    // and it is not -ve, then calculate power using simple multiplication\r\n    // There is a problem in from_double as it doesn't return exact\r\n    // values (for example, passing 1.002441 in num to from_double would\r\n    // return 1.00244099999999). btw, this problem exists even in Visual studio's\r\n    // watch window (try typing 1.002441 in Name column of watch window).\r\n    if (num2.NUM_IS_LONG() && !num2.num_is_neg()) {\r\n      d1 = num2.to_double();\r\n      let result: NUM_TYPE = NUM_TYPE.from_double(1);\r\n      for (let i: number = 0; i < d1; i++)\r\n        result = this.mul(result, num1);\r\n      return result;\r\n        }\r\n        else {\r\n      d0 = num1.to_double();\r\n      d1 = num2.to_double();\r\n      if (d0 < 0.0 && d1 !== <number> d1)\r\n        d0 = 0.0;\r\n      /* pwr (0.0, 0.0) -> error */\r\n      /* ----------------------- */\r\n      else if (d0 !== 0.0)\r\n        d0 = Math.pow(d0, d1);\r\n    }\r\n\r\n    return NUM_TYPE.from_double(d0);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate double to NUM_TYPE\r\n  /// </summary>\r\n  /// <param name = \"double\">to translate\r\n  /// </param>\r\n  /// <returns> NUM_TYPE of the double\r\n  /// </returns>\r\n  static from_double(d0: number): NUM_TYPE {\r\n    let array: Int8Array = NUM_TYPE.double_2_sbyteArray(d0);\r\n    return NUM_TYPE.storage_mg_4_float(8, array);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate byte array  to NUM_TYPE\r\n  /// </summary>\r\n  /// <param name = \"len\">of the needed number(8)\r\n  /// </param>\r\n  /// <param name = \"byte\">array mask\r\n  /// </param>\r\n  /// <returns> NUM_TYPE for the needed attributes\r\n  /// </returns>\r\n  private static storage_mg_4_float(len: number, inp: Int8Array): NUM_TYPE {\r\n    let cinp: number[];\r\n    let sign: number;\r\n    let tmp1: number;\r\n    let exp: number;\r\n    let bias: number;\r\n    let long1: number;\r\n    let long2: number;\r\n\r\n    cinp = new Array<number>(inp.length);\r\n    for (tmp1 = 0;\r\n         tmp1 < inp.length;\r\n         tmp1++)\r\n      cinp[tmp1] = NUM_TYPE.toUByte(inp[tmp1]);\r\n\r\n    sign = cinp[len - 1];\r\n    if (len === 4) {\r\n      exp = <number>((cinp[2] >> 7) | ((cinp[3] & 0x7F) << 1));\r\n      bias = 150; // 126 + (1 + 23);\r\n      long1 = 0;\r\n      long2 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(0, cinp[2] | 0x80), NUM_TYPE.MK_SHRT(cinp[1], cinp[0]));\r\n    }\r\n    else {\r\n      exp = <number>(((cinp[7] & 0x7F) << 4) | (cinp[6] >> 4));\r\n      bias = 1075; // 1022 + (1 + 20 + 32);\r\n      long1 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(0, (cinp[6] & 0x0F) | 0x10), NUM_TYPE.MK_SHRT(cinp[5], cinp[4]));\r\n      long2 = NUM_TYPE.MK_LONG(NUM_TYPE.MK_SHRT(cinp[3], cinp[2]), NUM_TYPE.MK_SHRT(cinp[1], cinp[0]));\r\n    }\r\n    return NUM_TYPE.storage_num_4_fld_flt(long1, long2, 18, sign, bias, exp);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   translate byte array  to NUM_TYPE (like in Magic Souce code).\r\n  /// </summary>\r\n  private static storage_num_4_fld_flt(long1: number, long2: number, dec: number, sign: number, bias: number, expr: number): NUM_TYPE {\r\n    let base_Num16Pwrs: Int8Array[] = [\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 2, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 2), 40, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 3), 6, 55, 36]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 1, 4, 85, 76]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 4), 16, 77, 72, 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 2, 68, 43, 54, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 5), 42, 94, 96, 72, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 6), 6, 87, 19, 47, 67, 36]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 1, 9, 95, 11, 62, 77, 76]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 7), 17, 59, 21, 86, 4, 44, 16]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 2, 81, 47, 49, 76, 71, 6, 56]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 8), 45, 3, 59, 96, 27, 37, 4, 96]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 9), 7, 20, 57, 59, 40, 37, 92, 79, 36])\r\n    ];\r\n\r\n    let base_Num2Pwrs: Int8Array[] = [\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 1]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 2]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 4]),\r\n      new Int8Array([NUM_TYPE.toSByte(NUM_TYPE.EXP_BIAS + 1), 8])\r\n    ];\r\n    let tmpnum: NUM_TYPE = new NUM_TYPE();\r\n    let outVal: NUM_TYPE = new NUM_TYPE();\r\n    let exp: number = <number>expr;\r\n    if (exp === 0) {\r\n      outVal.NUM_ZERO();\r\n      return outVal;\r\n    }\r\n    outVal.num_4_ulong(long2);\r\n    if (long1 !== 0) {\r\n      tmpnum.num_4_ulong(long1);\r\n      tmpnum = NUM_TYPE.mul(tmpnum, new NUM_TYPE(base_Num16Pwrs[8]));\r\n      outVal = NUM_TYPE.add(tmpnum, outVal);\r\n    }\r\n    exp = <number>(exp - bias);\r\n    if (exp < 0) {\r\n      exp = -exp;\r\n      while (exp >= 60) {\r\n        outVal = NUM_TYPE.div(outVal, new NUM_TYPE(base_Num16Pwrs[14]));\r\n        exp -= 56;\r\n      }\r\n      tmpnum = NUM_TYPE.mul(new NUM_TYPE(base_Num16Pwrs[exp >> 2]),\r\n        new NUM_TYPE(base_Num2Pwrs[exp & 3]));\r\n      outVal = NUM_TYPE.div(outVal, tmpnum);\r\n    }\r\n    else {\r\n      if (exp >= 60) {\r\n        outVal.NUM_ZERO();\r\n        return outVal;\r\n      }\r\n      tmpnum = NUM_TYPE.mul(new NUM_TYPE(base_Num16Pwrs[exp >> 2]),\r\n        new NUM_TYPE(base_Num2Pwrs[exp & 3]));\r\n      outVal = NUM_TYPE.mul(outVal, tmpnum);\r\n    }\r\n    if ((sign & 0x80) !== 0)\r\n      outVal._data[0] = outVal._data[0] | NUM_TYPE.SIGN_MASK;\r\n    outVal.round(dec);\r\n    return outVal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Mathematical functions implementation\r\n  /// </summary>\r\n  static eval_op_log(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 == null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n    let d: number = val1.to_double();\r\n\r\n    if (d > 0.0)\r\n      resVal = NUM_TYPE.from_double(Math.log(d));\r\n    else\r\n      resVal.NUM_ZERO();\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_exp(val1: NUM_TYPE): NUM_TYPE {\r\n    let resVal: NUM_TYPE;\r\n\r\n    if (val1 === null)\r\n      return null;\r\n      let d: number = val1.to_double();\r\n    resVal = NUM_TYPE.from_double(Math.exp(d));\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_abs(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE(val1);\r\n    resVal.num_abs();\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_sin(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n    let d: number = val1.to_double();\r\n    resVal = NUM_TYPE.from_double(Math.sin(d));\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_cos(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n      let d: number = val1.to_double();\r\n    resVal = NUM_TYPE.from_double(Math.cos(d));\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_tan(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 == null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n    let d: number = val1.to_double();\r\n    resVal = NUM_TYPE.from_double(Math.tan(d));\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_asin(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n    let d: number = val1.to_double();\r\n    if (d <= 1.0 && d >= -1.0)\r\n      resVal = NUM_TYPE.from_double(Math.asin(d));\r\n    else\r\n      resVal = NUM_TYPE.from_double(0.0);\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_acos(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n    let d: number = val1.to_double();\r\n\r\n    if (d <= 1.0 && d >= -1.0)\r\n      resVal = NUM_TYPE.from_double(Math.acos(d));\r\n    else\r\n      resVal = NUM_TYPE.from_double(0.0);\r\n    return resVal;\r\n  }\r\n\r\n  static eval_op_atan(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n    let resVal: NUM_TYPE = new NUM_TYPE();\r\n      let d: number = val1.to_double();\r\n    resVal = NUM_TYPE.from_double(Math.atan(d));\r\n    return resVal;\r\n  }\r\n\r\n  num_abs(): void {\r\n    let l: number;\r\n    if (this.NUM_IS_LONG()) {\r\n      l = this.NUM_LONG();\r\n      if (l < 0)\r\n        l = -l;\r\n      this.NUM_4_LONG(l);\r\n      return;\r\n    }\r\n    this._data[0] &= NUM_TYPE.toSByte(~NUM_TYPE.SIGN_MASK);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Randomal Math function\r\n  /// </summary>\r\n  static eval_op_rand(val1: NUM_TYPE): NUM_TYPE {\r\n    if (val1 === null)\r\n      return null;\r\n\r\n    let rand_initialized: boolean = Randomizer.get_initialized();\r\n    let rand_mod: NUM_TYPE;\r\n    let rand_mul: NUM_TYPE;\r\n    let rand_seed: NUM_TYPE;\r\n\r\n    let tmp_num: NUM_TYPE = new NUM_TYPE();\r\n\r\n    if (!rand_initialized) {\r\n      Randomizer.set_initialized(); // set to true\r\n      rand_mod = new NUM_TYPE();\r\n      rand_mul = new NUM_TYPE();\r\n      rand_seed = new NUM_TYPE();\r\n      rand_mod.num_4_a_std(\"100000007\");\r\n      rand_mul.num_4_a_std(\"75000007\");\r\n      rand_seed.num_4_a_std(\"12345678\");\r\n\r\n      Randomizer.set_mod(rand_mod.to_double());\r\n      Randomizer.set_mul(rand_mul.to_double());\r\n      Randomizer.set_seed(rand_seed.to_double());\r\n        }\r\n        else {\r\n      rand_mod = NUM_TYPE.from_double(Randomizer.get_mod());\r\n      rand_mul = NUM_TYPE.from_double(Randomizer.get_mul());\r\n      rand_seed = NUM_TYPE.from_double(Randomizer.get_seed());\r\n        }\r\n\r\n    if (!val1.num_is_zero()) {\r\n      if (val1.num_is_neg())\r\n        rand_seed.NUM_4_LONG(NUM_TYPE.hash_rand());\r\n      else\r\n        rand_seed = new NUM_TYPE(val1);\r\n      }\r\n      else {\r\n      if (rand_seed.num_is_neg()) {\r\n        tmp_num.NUM_4_LONG(-1);\r\n        rand_seed = NUM_TYPE.mul(rand_seed, tmp_num);\r\n      }\r\n    }\r\n\r\n    rand_seed = NUM_TYPE.mul(rand_seed, rand_mul);\r\n    rand_seed = NUM_TYPE.mod(rand_seed, rand_mod);\r\n    tmp_num = NUM_TYPE.div(rand_seed, rand_mod);\r\n    // reset globals variables\r\n    Randomizer.set_mod(rand_mod.to_double());\r\n    Randomizer.set_mul(rand_mul.to_double());\r\n    Randomizer.set_seed(rand_seed.to_double());\r\n    return tmp_num;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a random value to use as the ctl encription  key\r\n  /// </summary>\r\n  private static hash_rand(): number {\r\n    return ((new Date().getMilliseconds()) ^ Math.random() * 12345678);\r\n    // let array: number[] = new Array<number>(100);\r\n    // for (let _ai: number = 0; _ai < array.length; ++_ai)\r\n    //   array[_ai] = 0;\r\n    // new Random().NextBytes(array);\r\n    // return <number>(Misc.getSystemMilliseconds() ^ NUM_TYPE.hash_str_new(array));\r\n  }\r\n}\r\n\r\nexport class OperData {\r\n  NUM_Diff_: number = 0;\r\n  NUM_Exp1_: number = 0;\r\n  NUM_Exp2_: number = 0;\r\n}\r\n\r\n"]}