// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) braces deadcode fieldsfirst 
// Source File Name:   LnxLibThin.java
// Class Version:      45.3

package oracle.sql;

import java.sql.SQLException;
import java.text.DecimalFormatSymbols;
import java.util.Locale;
import oracle.core.lmx.CoreException;
import oracle.gss.util.NLSLocale;

// Referenced classes of package oracle.sql:
//            Datum, LnxLib, LnxLibThinFormat, NUMBER

// flag ACC_SUPER is set
class LnxLibThin
    implements LnxLib
{
    // Constants:          859
    // Interfaces:         1
    // Fields:             46
    // Methods:            57
    // Class Attributes:   2

    private class lnxqc
    {
        // Constants:          125
        // Interfaces:         0
        // Fields:             51
        // Methods:            1
        // Class Attributes:   2


        /* private final LnxLibThin this$0; */ /* synthetic field */
        static final int LNXQC0 = 0;
        static final int LNXQC1 = 1;
        static final int LNXQC2 = 2;
        static final int LNXQC3 = 3;
        static final int LNXQC4 = 4;
        static final int LNXQC5 = 5;
        static final int LNXQC6 = 6;
        static final int LNXQC7 = 7;
        static final int LNXQC8 = 8;
        static final int LNXQC9 = 9;
        static final int LNXQCPLUS = 10;
        static final int LNXQCMINUS = 11;
        static final int LNXQCSPACE = 12;
        static final int LNXQCDOT = 13;
        static final int LNXQCCOMMA = 14;
        static final int LNXQCDOLLR = 15;
        static final int LNXQCLT = 16;
        static final int LNXQCGRT = 17;
        static final int LNXQCLPT = 18;
        static final int LNXQCRPT = 19;
        static final int LNXQCHASH = 20;
        static final int LNXQCTILDE = 21;
        static final int LNXQCASML = 22;
        static final int LNXQCBSML = 23;
        static final int LNXQCCSML = 24;
        static final int LNXQCDSML = 25;
        static final int LNXQCESML = 26;
        static final int LNXQCFSML = 27;
        static final int LNXQCGSML = 28;
        static final int LNXQCISML = 29;
        static final int LNXQCLSML = 30;
        static final int LNXQCMSML = 31;
        static final int LNXQCPSML = 32;
        static final int LNXQCRSML = 33;
        static final int LNXQCSSML = 34;
        static final int LNXQCTSML = 35;
        static final int LNXQCVSML = 36;
        static final int LNXQCALRG = 37;
        static final int LNXQCBLRG = 38;
        static final int LNXQCCLRG = 39;
        static final int LNXQCDLRG = 40;
        static final int LNXQCELRG = 41;
        static final int LNXQCFLRG = 42;
        static final int LNXQCILRG = 43;
        static final int LNXQCLLRG = 44;
        static final int LNXQCMLRG = 45;
        static final int LNXQCPLRG = 46;
        static final int LNXQCRLRG = 47;
        static final int LNXQCSLRG = 48;
        static final int LNXQCTLRG = 49;
        // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin$lnxqc; At 0 10 Range 0 9 Init 0 fixed
        // Parameter  1 added: Name lnxlibthin Type Loracle/sql/LnxLibThin; At 0 10 Range 0 9 Init 0
        // RetValue   2 added: Name <returnValue> Type V At 0 10 Range 0 9 Init 0 fixed

        // Decompiling method: <init>  Signature: (Loracle/sql/LnxLibThin;)V
        // Max stack: 2, #locals: 2, #params: 2
        // Code length: 10 bytes, Code offset: 1969
        // Line Number Table found: 5 entries
        lnxqc()
        {
            super();
            /* this$0 = lnxlibthin; */
            return;
        }
    }


    private static final byte lnxqone[] = {
        -63, 2
    };
    private static final byte lnxqtwo[] = {
        -63, 3
    };
    private static final int LNXQACOS = 0;
    private static final int LNXQASIN = 1;
    private static final int LNXQATAN = 2;
    private static final int LNXQCOS = 3;
    private static final int LNXQSIN = 4;
    private static final int LNXQTAN = 5;
    private static final int LNXQCSH = 6;
    private static final int LNXQSNH = 7;
    private static final int LNXQTNH = 8;
    private static final int LNXQEXP = 9;
    private static final int LNXM_NUM = 22;
    private static final int LNXDIGS = 20;
    private static final int LNXSGNBT = 128;
    private static final int LNXEXPMX = 127;
    private static final int LNXEXPMN = 0;
    private static final int LNXEXPBS = 64;
    private static final int LNXBASE = 100;
    private static final int LNXMXFMT = 64;
    private static final int LNXMXOUT = 40;
    private static final int LNXDIV_LNXBASE_SQUARED = 10000;
    private static final int MINUB1MAXVAL = 255;
    private static final double ORANUM_FBASE = 100D;
    private final int LNXQNOSGN = 127;
    private final char LNXNFT_COMMA = ',';
    private final int LNXBYTEMASK = 255;
    private final int LNXSHORTMASK = 65535;
    private static byte LnxqFirstDigit[] = {
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 1
    };
    private static byte LnxqNegate[] = {
        0, 101, 100, 99, 98, 97, 96, 95, 94, 93, 
        92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 
        82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 
        72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 
        62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 
        52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 
        42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 
        32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 
        22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 
        12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 
        2, 1
    };
    private static byte LnxqTruncate_P[] = {
        0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
        1, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
        11, 21, 21, 21, 21, 21, 21, 21, 21, 21, 
        21, 31, 31, 31, 31, 31, 31, 31, 31, 31, 
        31, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
        41, 51, 51, 51, 51, 51, 51, 51, 51, 51, 
        51, 61, 61, 61, 61, 61, 61, 61, 61, 61, 
        61, 71, 71, 71, 71, 71, 71, 71, 71, 71, 
        71, 81, 81, 81, 81, 81, 81, 81, 81, 81, 
        81, 91, 91, 91, 91, 91, 91, 91, 91, 91, 
        91
    };
    private static byte LnxqTruncate_N[] = {
        0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 
        11, 11, 21, 21, 21, 21, 21, 21, 21, 21, 
        21, 21, 31, 31, 31, 31, 31, 31, 31, 31, 
        31, 31, 41, 41, 41, 41, 41, 41, 41, 41, 
        41, 41, 51, 51, 51, 51, 51, 51, 51, 51, 
        51, 51, 61, 61, 61, 61, 61, 61, 61, 61, 
        61, 61, 71, 71, 71, 71, 71, 71, 71, 71, 
        71, 71, 81, 81, 81, 81, 81, 81, 81, 81, 
        81, 81, 91, 91, 91, 91, 91, 91, 91, 91, 
        91, 91, 101, 101, 101, 101, 101, 101, 101, 101, 
        101, 101
    };
    private static byte LnxqRound_P[] = {
        0, 1, 1, 1, 1, 1, 11, 11, 11, 11, 
        11, 11, 11, 11, 11, 11, 21, 21, 21, 21, 
        21, 21, 21, 21, 21, 21, 31, 31, 31, 31, 
        31, 31, 31, 31, 31, 31, 41, 41, 41, 41, 
        41, 41, 41, 41, 41, 41, 51, 51, 51, 51, 
        51, 51, 51, 51, 51, 51, 61, 61, 61, 61, 
        61, 61, 61, 61, 61, 61, 71, 71, 71, 71, 
        71, 71, 71, 71, 71, 71, 81, 81, 81, 81, 
        81, 81, 81, 81, 81, 81, 91, 91, 91, 91, 
        91, 91, 91, 91, 91, 91, 101, 101, 101, 101, 
        101
    };
    private static byte LnxqRound_N[] = {
        0, 0, 1, 1, 1, 1, 1, 11, 11, 11, 
        11, 11, 11, 11, 11, 11, 11, 21, 21, 21, 
        21, 21, 21, 21, 21, 21, 21, 31, 31, 31, 
        31, 31, 31, 31, 31, 31, 31, 41, 41, 41, 
        41, 41, 41, 41, 41, 41, 41, 51, 51, 51, 
        51, 51, 51, 51, 51, 51, 51, 61, 61, 61, 
        61, 61, 61, 61, 61, 61, 61, 71, 71, 71, 
        71, 71, 71, 71, 71, 71, 71, 81, 81, 81, 
        81, 81, 81, 81, 81, 81, 81, 91, 91, 91, 
        91, 91, 91, 91, 91, 91, 91, 101, 101, 101, 
        101, 101
    };
    private static byte LnxqComponents_P[][] = {
        new byte[2], new byte[2], {
            0, 1
        }, {
            0, 2
        }, {
            0, 3
        }, {
            0, 4
        }, {
            0, 5
        }, {
            0, 6
        }, {
            0, 7
        }, {
            0, 8
        }, 
        {
            0, 9
        }, {
            1, 0
        }, {
            1, 1
        }, {
            1, 2
        }, {
            1, 3
        }, {
            1, 4
        }, {
            1, 5
        }, {
            1, 6
        }, {
            1, 7
        }, {
            1, 8
        }, 
        {
            1, 9
        }, {
            2, 0
        }, {
            2, 1
        }, {
            2, 2
        }, {
            2, 3
        }, {
            2, 4
        }, {
            2, 5
        }, {
            2, 6
        }, {
            2, 7
        }, {
            2, 8
        }, 
        {
            2, 9
        }, {
            3, 0
        }, {
            3, 1
        }, {
            3, 2
        }, {
            3, 3
        }, {
            3, 4
        }, {
            3, 5
        }, {
            3, 6
        }, {
            3, 7
        }, {
            3, 8
        }, 
        {
            3, 9
        }, {
            4, 0
        }, {
            4, 1
        }, {
            4, 2
        }, {
            4, 3
        }, {
            4, 4
        }, {
            4, 5
        }, {
            4, 6
        }, {
            4, 7
        }, {
            4, 8
        }, 
        {
            4, 9
        }, {
            5, 0
        }, {
            5, 1
        }, {
            5, 2
        }, {
            5, 3
        }, {
            5, 4
        }, {
            5, 5
        }, {
            5, 6
        }, {
            5, 7
        }, {
            5, 8
        }, 
        {
            5, 9
        }, {
            6, 0
        }, {
            6, 1
        }, {
            6, 2
        }, {
            6, 3
        }, {
            6, 4
        }, {
            6, 5
        }, {
            6, 6
        }, {
            6, 7
        }, {
            6, 8
        }, 
        {
            6, 9
        }, {
            7, 0
        }, {
            7, 1
        }, {
            7, 2
        }, {
            7, 3
        }, {
            7, 4
        }, {
            7, 5
        }, {
            7, 6
        }, {
            7, 7
        }, {
            7, 8
        }, 
        {
            7, 9
        }, {
            8, 0
        }, {
            8, 1
        }, {
            8, 2
        }, {
            8, 3
        }, {
            8, 4
        }, {
            8, 5
        }, {
            8, 6
        }, {
            8, 7
        }, {
            8, 8
        }, 
        {
            8, 9
        }, {
            9, 0
        }, {
            9, 1
        }, {
            9, 2
        }, {
            9, 3
        }, {
            9, 4
        }, {
            9, 5
        }, {
            9, 6
        }, {
            9, 7
        }, {
            9, 8
        }, 
        {
            9, 9
        }
    };
    private static byte LnxqComponents_N[][] = {
        new byte[2], new byte[2], {
            9, 9
        }, {
            9, 8
        }, {
            9, 7
        }, {
            9, 6
        }, {
            9, 5
        }, {
            9, 4
        }, {
            9, 3
        }, {
            9, 2
        }, 
        {
            9, 1
        }, {
            9, 0
        }, {
            8, 9
        }, {
            8, 8
        }, {
            8, 7
        }, {
            8, 6
        }, {
            8, 5
        }, {
            8, 4
        }, {
            8, 3
        }, {
            8, 2
        }, 
        {
            8, 1
        }, {
            8, 0
        }, {
            7, 9
        }, {
            7, 8
        }, {
            7, 7
        }, {
            7, 6
        }, {
            7, 5
        }, {
            7, 4
        }, {
            7, 3
        }, {
            7, 2
        }, 
        {
            7, 1
        }, {
            7, 0
        }, {
            6, 9
        }, {
            6, 8
        }, {
            6, 7
        }, {
            6, 6
        }, {
            6, 5
        }, {
            6, 4
        }, {
            6, 3
        }, {
            6, 2
        }, 
        {
            6, 1
        }, {
            6, 0
        }, {
            5, 9
        }, {
            5, 8
        }, {
            5, 7
        }, {
            5, 6
        }, {
            5, 5
        }, {
            5, 4
        }, {
            5, 3
        }, {
            5, 2
        }, 
        {
            5, 1
        }, {
            5, 0
        }, {
            4, 9
        }, {
            4, 8
        }, {
            4, 7
        }, {
            4, 6
        }, {
            4, 5
        }, {
            4, 4
        }, {
            4, 3
        }, {
            4, 2
        }, 
        {
            4, 1
        }, {
            4, 0
        }, {
            3, 9
        }, {
            3, 8
        }, {
            3, 7
        }, {
            3, 6
        }, {
            3, 5
        }, {
            3, 4
        }, {
            3, 3
        }, {
            3, 2
        }, 
        {
            3, 1
        }, {
            3, 0
        }, {
            2, 9
        }, {
            2, 8
        }, {
            2, 7
        }, {
            2, 6
        }, {
            2, 5
        }, {
            2, 4
        }, {
            2, 3
        }, {
            2, 2
        }, 
        {
            2, 1
        }, {
            2, 0
        }, {
            1, 9
        }, {
            1, 8
        }, {
            1, 7
        }, {
            1, 6
        }, {
            1, 5
        }, {
            1, 4
        }, {
            1, 3
        }, {
            1, 2
        }, 
        {
            1, 1
        }, {
            1, 0
        }, {
            0, 9
        }, {
            0, 8
        }, {
            0, 7
        }, {
            0, 6
        }, {
            0, 5
        }, {
            0, 4
        }, {
            0, 3
        }, {
            0, 2
        }, 
        {
            0, 1
        }, new byte[2]
    };
    private static byte LnxqAdd_PPP[][] = {
        new byte[2], {
            0, 1
        }, {
            1, 0
        }, {
            2, 0
        }, {
            3, 0
        }, {
            4, 0
        }, {
            5, 0
        }, {
            6, 0
        }, {
            7, 0
        }, {
            8, 0
        }, 
        {
            9, 0
        }, {
            10, 0
        }, {
            11, 0
        }, {
            12, 0
        }, {
            13, 0
        }, {
            14, 0
        }, {
            15, 0
        }, {
            16, 0
        }, {
            17, 0
        }, {
            18, 0
        }, 
        {
            19, 0
        }, {
            20, 0
        }, {
            21, 0
        }, {
            22, 0
        }, {
            23, 0
        }, {
            24, 0
        }, {
            25, 0
        }, {
            26, 0
        }, {
            27, 0
        }, {
            28, 0
        }, 
        {
            29, 0
        }, {
            30, 0
        }, {
            31, 0
        }, {
            32, 0
        }, {
            33, 0
        }, {
            34, 0
        }, {
            35, 0
        }, {
            36, 0
        }, {
            37, 0
        }, {
            38, 0
        }, 
        {
            39, 0
        }, {
            40, 0
        }, {
            41, 0
        }, {
            42, 0
        }, {
            43, 0
        }, {
            44, 0
        }, {
            45, 0
        }, {
            46, 0
        }, {
            47, 0
        }, {
            48, 0
        }, 
        {
            49, 0
        }, {
            50, 0
        }, {
            51, 0
        }, {
            52, 0
        }, {
            53, 0
        }, {
            54, 0
        }, {
            55, 0
        }, {
            56, 0
        }, {
            57, 0
        }, {
            58, 0
        }, 
        {
            59, 0
        }, {
            60, 0
        }, {
            61, 0
        }, {
            62, 0
        }, {
            63, 0
        }, {
            64, 0
        }, {
            65, 0
        }, {
            66, 0
        }, {
            67, 0
        }, {
            68, 0
        }, 
        {
            69, 0
        }, {
            70, 0
        }, {
            71, 0
        }, {
            72, 0
        }, {
            73, 0
        }, {
            74, 0
        }, {
            75, 0
        }, {
            76, 0
        }, {
            77, 0
        }, {
            78, 0
        }, 
        {
            79, 0
        }, {
            80, 0
        }, {
            81, 0
        }, {
            82, 0
        }, {
            83, 0
        }, {
            84, 0
        }, {
            85, 0
        }, {
            86, 0
        }, {
            87, 0
        }, {
            88, 0
        }, 
        {
            89, 0
        }, {
            90, 0
        }, {
            91, 0
        }, {
            92, 0
        }, {
            93, 0
        }, {
            94, 0
        }, {
            95, 0
        }, {
            96, 0
        }, {
            97, 0
        }, {
            98, 0
        }, 
        {
            99, 0
        }, {
            100, 0
        }, {
            1, 1
        }, {
            2, 1
        }, {
            3, 1
        }, {
            4, 1
        }, {
            5, 1
        }, {
            6, 1
        }, {
            7, 1
        }, {
            8, 1
        }, 
        {
            9, 1
        }, {
            10, 1
        }, {
            11, 1
        }, {
            12, 1
        }, {
            13, 1
        }, {
            14, 1
        }, {
            15, 1
        }, {
            16, 1
        }, {
            17, 1
        }, {
            18, 1
        }, 
        {
            19, 1
        }, {
            20, 1
        }, {
            21, 1
        }, {
            22, 1
        }, {
            23, 1
        }, {
            24, 1
        }, {
            25, 1
        }, {
            26, 1
        }, {
            27, 1
        }, {
            28, 1
        }, 
        {
            29, 1
        }, {
            30, 1
        }, {
            31, 1
        }, {
            32, 1
        }, {
            33, 1
        }, {
            34, 1
        }, {
            35, 1
        }, {
            36, 1
        }, {
            37, 1
        }, {
            38, 1
        }, 
        {
            39, 1
        }, {
            40, 1
        }, {
            41, 1
        }, {
            42, 1
        }, {
            43, 1
        }, {
            44, 1
        }, {
            45, 1
        }, {
            46, 1
        }, {
            47, 1
        }, {
            48, 1
        }, 
        {
            49, 1
        }, {
            50, 1
        }, {
            51, 1
        }, {
            52, 1
        }, {
            53, 1
        }, {
            54, 1
        }, {
            55, 1
        }, {
            56, 1
        }, {
            57, 1
        }, {
            58, 1
        }, 
        {
            59, 1
        }, {
            60, 1
        }, {
            61, 1
        }, {
            62, 1
        }, {
            63, 1
        }, {
            64, 1
        }, {
            65, 1
        }, {
            66, 1
        }, {
            67, 1
        }, {
            68, 1
        }, 
        {
            69, 1
        }, {
            70, 1
        }, {
            71, 1
        }, {
            72, 1
        }, {
            73, 1
        }, {
            74, 1
        }, {
            75, 1
        }, {
            76, 1
        }, {
            77, 1
        }, {
            78, 1
        }, 
        {
            79, 1
        }, {
            80, 1
        }, {
            81, 1
        }, {
            82, 1
        }, {
            83, 1
        }, {
            84, 1
        }, {
            85, 1
        }, {
            86, 1
        }, {
            87, 1
        }, {
            88, 1
        }, 
        {
            89, 1
        }, {
            90, 1
        }, {
            91, 1
        }, {
            92, 1
        }, {
            93, 1
        }, {
            94, 1
        }, {
            95, 1
        }, {
            96, 1
        }, {
            97, 1
        }, {
            98, 1
        }, 
        {
            99, 1
        }, {
            100, 1
        }
    };
    private static byte LnxqAdd_NNN[][] = {
        {
            0, 2
        }, {
            0, 1
        }, new byte[2], new byte[2], new byte[2], {
            2, 1
        }, {
            3, 1
        }, {
            4, 1
        }, {
            5, 1
        }, {
            6, 1
        }, {
            7, 1
        }, {
            8, 1
        }, {
            9, 1
        }, {
            10, 1
        }, {
            11, 1
        }, {
            12, 1
        }, {
            13, 1
        }, {
            14, 1
        }, {
            15, 1
        }, {
            16, 1
        }, {
            17, 1
        }, {
            18, 1
        }, {
            19, 1
        }, {
            20, 1
        }, {
            21, 1
        }, {
            22, 1
        }, {
            23, 1
        }, {
            24, 1
        }, {
            25, 1
        }, {
            26, 1
        }, {
            27, 1
        }, {
            28, 1
        }, {
            29, 1
        }, {
            30, 1
        }, {
            31, 1
        }, {
            32, 1
        }, {
            33, 1
        }, {
            34, 1
        }, {
            35, 1
        }, {
            36, 1
        }, {
            37, 1
        }, {
            38, 1
        }, {
            39, 1
        }, {
            40, 1
        }, {
            41, 1
        }, {
            42, 1
        }, {
            43, 1
        }, {
            44, 1
        }, {
            45, 1
        }, {
            46, 1
        }, {
            47, 1
        }, {
            48, 1
        }, {
            49, 1
        }, {
            50, 1
        }, {
            51, 1
        }, {
            52, 1
        }, {
            53, 1
        }, {
            54, 1
        }, {
            55, 1
        }, {
            56, 1
        }, {
            57, 1
        }, {
            58, 1
        }, {
            59, 1
        }, {
            60, 1
        }, {
            61, 1
        }, {
            62, 1
        }, {
            63, 1
        }, {
            64, 1
        }, {
            65, 1
        }, {
            66, 1
        }, {
            67, 1
        }, {
            68, 1
        }, {
            69, 1
        }, {
            70, 1
        }, {
            71, 1
        }, {
            72, 1
        }, {
            73, 1
        }, {
            74, 1
        }, {
            75, 1
        }, {
            76, 1
        }, {
            77, 1
        }, {
            78, 1
        }, {
            79, 1
        }, {
            80, 1
        }, {
            81, 1
        }, {
            82, 1
        }, {
            83, 1
        }, {
            84, 1
        }, {
            85, 1
        }, {
            86, 1
        }, {
            87, 1
        }, {
            88, 1
        }, {
            89, 1
        }, {
            90, 1
        }, {
            91, 1
        }, {
            92, 1
        }, {
            93, 1
        }, {
            94, 1
        }, {
            95, 1
        }, {
            96, 1
        }, {
            97, 1
        }, {
            98, 1
        }, {
            99, 1
        }, {
            100, 1
        }, {
            101, 1
        }, {
            2, 2
        }, {
            3, 2
        }, {
            4, 2
        }, {
            5, 2
        }, {
            6, 2
        }, {
            7, 2
        }, {
            8, 2
        }, {
            9, 2
        }, {
            10, 2
        }, {
            11, 2
        }, {
            12, 2
        }, {
            13, 2
        }, {
            14, 2
        }, {
            15, 2
        }, {
            16, 2
        }, {
            17, 2
        }, {
            18, 2
        }, {
            19, 2
        }, {
            20, 2
        }, {
            21, 2
        }, {
            22, 2
        }, {
            23, 2
        }, {
            24, 2
        }, {
            25, 2
        }, {
            26, 2
        }, {
            27, 2
        }, {
            28, 2
        }, {
            29, 2
        }, {
            30, 2
        }, {
            31, 2
        }, {
            32, 2
        }, {
            33, 2
        }, {
            34, 2
        }, {
            35, 2
        }, {
            36, 2
        }, {
            37, 2
        }, {
            38, 2
        }, {
            39, 2
        }, {
            40, 2
        }, {
            41, 2
        }, {
            42, 2
        }, {
            43, 2
        }, {
            44, 2
        }, {
            45, 2
        }, {
            46, 2
        }, {
            47, 2
        }, {
            48, 2
        }, {
            49, 2
        }, {
            50, 2
        }, {
            51, 2
        }, {
            52, 2
        }, {
            53, 2
        }, {
            54, 2
        }, {
            55, 2
        }, {
            56, 2
        }, {
            57, 2
        }, {
            58, 2
        }, {
            59, 2
        }, {
            60, 2
        }, {
            61, 2
        }, {
            62, 2
        }, {
            63, 2
        }, {
            64, 2
        }, {
            65, 2
        }, {
            66, 2
        }, {
            67, 2
        }, {
            68, 2
        }, {
            69, 2
        }, {
            70, 2
        }, {
            71, 2
        }, {
            72, 2
        }, {
            73, 2
        }, {
            74, 2
        }, {
            75, 2
        }, {
            76, 2
        }, {
            77, 2
        }, {
            78, 2
        }, {
            79, 2
        }, {
            80, 2
        }, {
            81, 2
        }, {
            82, 2
        }, {
            83, 2
        }, {
            84, 2
        }, {
            85, 2
        }, {
            86, 2
        }, {
            87, 2
        }, {
            88, 2
        }, {
            89, 2
        }, {
            90, 2
        }, {
            91, 2
        }, {
            92, 2
        }, {
            93, 2
        }, {
            94, 2
        }, {
            95, 2
        }, {
            96, 2
        }, {
            97, 2
        }, {
            98, 2
        }, {
            99, 2
        }, {
            100, 2
        }, {
            101, 2
        }
    };
    private static byte LnxqAdd_PNP[][] = {
        {
            0, 2
        }, {
            0, 1
        }, new byte[2], new byte[2], {
            1, 1
        }, {
            2, 1
        }, {
            3, 1
        }, {
            4, 1
        }, {
            5, 1
        }, {
            6, 1
        }, {
            7, 1
        }, {
            8, 1
        }, {
            9, 1
        }, {
            10, 1
        }, {
            11, 1
        }, {
            12, 1
        }, {
            13, 1
        }, {
            14, 1
        }, {
            15, 1
        }, {
            16, 1
        }, {
            17, 1
        }, {
            18, 1
        }, {
            19, 1
        }, {
            20, 1
        }, {
            21, 1
        }, {
            22, 1
        }, {
            23, 1
        }, {
            24, 1
        }, {
            25, 1
        }, {
            26, 1
        }, {
            27, 1
        }, {
            28, 1
        }, {
            29, 1
        }, {
            30, 1
        }, {
            31, 1
        }, {
            32, 1
        }, {
            33, 1
        }, {
            34, 1
        }, {
            35, 1
        }, {
            36, 1
        }, {
            37, 1
        }, {
            38, 1
        }, {
            39, 1
        }, {
            40, 1
        }, {
            41, 1
        }, {
            42, 1
        }, {
            43, 1
        }, {
            44, 1
        }, {
            45, 1
        }, {
            46, 1
        }, {
            47, 1
        }, {
            48, 1
        }, {
            49, 1
        }, {
            50, 1
        }, {
            51, 1
        }, {
            52, 1
        }, {
            53, 1
        }, {
            54, 1
        }, {
            55, 1
        }, {
            56, 1
        }, {
            57, 1
        }, {
            58, 1
        }, {
            59, 1
        }, {
            60, 1
        }, {
            61, 1
        }, {
            62, 1
        }, {
            63, 1
        }, {
            64, 1
        }, {
            65, 1
        }, {
            66, 1
        }, {
            67, 1
        }, {
            68, 1
        }, {
            69, 1
        }, {
            70, 1
        }, {
            71, 1
        }, {
            72, 1
        }, {
            73, 1
        }, {
            74, 1
        }, {
            75, 1
        }, {
            76, 1
        }, {
            77, 1
        }, {
            78, 1
        }, {
            79, 1
        }, {
            80, 1
        }, {
            81, 1
        }, {
            82, 1
        }, {
            83, 1
        }, {
            84, 1
        }, {
            85, 1
        }, {
            86, 1
        }, {
            87, 1
        }, {
            88, 1
        }, {
            89, 1
        }, {
            90, 1
        }, {
            91, 1
        }, {
            92, 1
        }, {
            93, 1
        }, {
            94, 1
        }, {
            95, 1
        }, {
            96, 1
        }, {
            97, 1
        }, {
            98, 1
        }, {
            99, 1
        }, {
            100, 1
        }, {
            1, 2
        }, {
            2, 2
        }, {
            3, 2
        }, {
            4, 2
        }, {
            5, 2
        }, {
            6, 2
        }, {
            7, 2
        }, {
            8, 2
        }, {
            9, 2
        }, {
            10, 2
        }, {
            11, 2
        }, {
            12, 2
        }, {
            13, 2
        }, {
            14, 2
        }, {
            15, 2
        }, {
            16, 2
        }, {
            17, 2
        }, {
            18, 2
        }, {
            19, 2
        }, {
            20, 2
        }, {
            21, 2
        }, {
            22, 2
        }, {
            23, 2
        }, {
            24, 2
        }, {
            25, 2
        }, {
            26, 2
        }, {
            27, 2
        }, {
            28, 2
        }, {
            29, 2
        }, {
            30, 2
        }, {
            31, 2
        }, {
            32, 2
        }, {
            33, 2
        }, {
            34, 2
        }, {
            35, 2
        }, {
            36, 2
        }, {
            37, 2
        }, {
            38, 2
        }, {
            39, 2
        }, {
            40, 2
        }, {
            41, 2
        }, {
            42, 2
        }, {
            43, 2
        }, {
            44, 2
        }, {
            45, 2
        }, {
            46, 2
        }, {
            47, 2
        }, {
            48, 2
        }, {
            49, 2
        }, {
            50, 2
        }, {
            51, 2
        }, {
            52, 2
        }, {
            53, 2
        }, {
            54, 2
        }, {
            55, 2
        }, {
            56, 2
        }, {
            57, 2
        }, {
            58, 2
        }, {
            59, 2
        }, {
            60, 2
        }, {
            61, 2
        }, {
            62, 2
        }, {
            63, 2
        }, {
            64, 2
        }, {
            65, 2
        }, {
            66, 2
        }, {
            67, 2
        }, {
            68, 2
        }, {
            69, 2
        }, {
            70, 2
        }, {
            71, 2
        }, {
            72, 2
        }, {
            73, 2
        }, {
            74, 2
        }, {
            75, 2
        }, {
            76, 2
        }, {
            77, 2
        }, {
            78, 2
        }, {
            79, 2
        }, {
            80, 2
        }, {
            81, 2
        }, {
            82, 2
        }, {
            83, 2
        }, {
            84, 2
        }, {
            85, 2
        }, {
            86, 2
        }, {
            87, 2
        }, {
            88, 2
        }, {
            89, 2
        }, {
            90, 2
        }, {
            91, 2
        }, {
            92, 2
        }, {
            93, 2
        }, {
            94, 2
        }, {
            95, 2
        }, {
            96, 2
        }, {
            97, 2
        }, {
            98, 2
        }, {
            99, 2
        }, {
            100, 2
        }
    };
    private static byte LnxqAdd_PNN[][] = {
        new byte[2], {
            0, 1
        }, new byte[2], {
            2, 0
        }, {
            3, 0
        }, {
            4, 0
        }, {
            5, 0
        }, {
            6, 0
        }, {
            7, 0
        }, {
            8, 0
        }, 
        {
            9, 0
        }, {
            10, 0
        }, {
            11, 0
        }, {
            12, 0
        }, {
            13, 0
        }, {
            14, 0
        }, {
            15, 0
        }, {
            16, 0
        }, {
            17, 0
        }, {
            18, 0
        }, 
        {
            19, 0
        }, {
            20, 0
        }, {
            21, 0
        }, {
            22, 0
        }, {
            23, 0
        }, {
            24, 0
        }, {
            25, 0
        }, {
            26, 0
        }, {
            27, 0
        }, {
            28, 0
        }, 
        {
            29, 0
        }, {
            30, 0
        }, {
            31, 0
        }, {
            32, 0
        }, {
            33, 0
        }, {
            34, 0
        }, {
            35, 0
        }, {
            36, 0
        }, {
            37, 0
        }, {
            38, 0
        }, 
        {
            39, 0
        }, {
            40, 0
        }, {
            41, 0
        }, {
            42, 0
        }, {
            43, 0
        }, {
            44, 0
        }, {
            45, 0
        }, {
            46, 0
        }, {
            47, 0
        }, {
            48, 0
        }, 
        {
            49, 0
        }, {
            50, 0
        }, {
            51, 0
        }, {
            52, 0
        }, {
            53, 0
        }, {
            54, 0
        }, {
            55, 0
        }, {
            56, 0
        }, {
            57, 0
        }, {
            58, 0
        }, 
        {
            59, 0
        }, {
            60, 0
        }, {
            61, 0
        }, {
            62, 0
        }, {
            63, 0
        }, {
            64, 0
        }, {
            65, 0
        }, {
            66, 0
        }, {
            67, 0
        }, {
            68, 0
        }, 
        {
            69, 0
        }, {
            70, 0
        }, {
            71, 0
        }, {
            72, 0
        }, {
            73, 0
        }, {
            74, 0
        }, {
            75, 0
        }, {
            76, 0
        }, {
            77, 0
        }, {
            78, 0
        }, 
        {
            79, 0
        }, {
            80, 0
        }, {
            81, 0
        }, {
            82, 0
        }, {
            83, 0
        }, {
            84, 0
        }, {
            85, 0
        }, {
            86, 0
        }, {
            87, 0
        }, {
            88, 0
        }, 
        {
            89, 0
        }, {
            90, 0
        }, {
            91, 0
        }, {
            92, 0
        }, {
            93, 0
        }, {
            94, 0
        }, {
            95, 0
        }, {
            96, 0
        }, {
            97, 0
        }, {
            98, 0
        }, 
        {
            99, 0
        }, {
            100, 0
        }, {
            101, 0
        }, {
            2, 1
        }, {
            3, 1
        }, {
            4, 1
        }, {
            5, 1
        }, {
            6, 1
        }, {
            7, 1
        }, {
            8, 1
        }, 
        {
            9, 1
        }, {
            10, 1
        }, {
            11, 1
        }, {
            12, 1
        }, {
            13, 1
        }, {
            14, 1
        }, {
            15, 1
        }, {
            16, 1
        }, {
            17, 1
        }, {
            18, 1
        }, 
        {
            19, 1
        }, {
            20, 1
        }, {
            21, 1
        }, {
            22, 1
        }, {
            23, 1
        }, {
            24, 1
        }, {
            25, 1
        }, {
            26, 1
        }, {
            27, 1
        }, {
            28, 1
        }, 
        {
            29, 1
        }, {
            30, 1
        }, {
            31, 1
        }, {
            32, 1
        }, {
            33, 1
        }, {
            34, 1
        }, {
            35, 1
        }, {
            36, 1
        }, {
            37, 1
        }, {
            38, 1
        }, 
        {
            39, 1
        }, {
            40, 1
        }, {
            41, 1
        }, {
            42, 1
        }, {
            43, 1
        }, {
            44, 1
        }, {
            45, 1
        }, {
            46, 1
        }, {
            47, 1
        }, {
            48, 1
        }, 
        {
            49, 1
        }, {
            50, 1
        }, {
            51, 1
        }, {
            52, 1
        }, {
            53, 1
        }, {
            54, 1
        }, {
            55, 1
        }, {
            56, 1
        }, {
            57, 1
        }, {
            58, 1
        }, 
        {
            59, 1
        }, {
            60, 1
        }, {
            61, 1
        }, {
            62, 1
        }, {
            63, 1
        }, {
            64, 1
        }, {
            65, 1
        }, {
            66, 1
        }, {
            67, 1
        }, {
            68, 1
        }, 
        {
            69, 1
        }, {
            70, 1
        }, {
            71, 1
        }, {
            72, 1
        }, {
            73, 1
        }, {
            74, 1
        }, {
            75, 1
        }, {
            76, 1
        }, {
            77, 1
        }, {
            78, 1
        }, 
        {
            79, 1
        }, {
            80, 1
        }, {
            81, 1
        }, {
            82, 1
        }, {
            83, 1
        }, {
            84, 1
        }, {
            85, 1
        }, {
            86, 1
        }, {
            87, 1
        }, {
            88, 1
        }, 
        {
            89, 1
        }, {
            90, 1
        }, {
            91, 1
        }, {
            92, 1
        }, {
            93, 1
        }, {
            94, 1
        }, {
            95, 1
        }, {
            96, 1
        }, {
            97, 1
        }, {
            98, 1
        }, 
        {
            99, 1
        }, {
            100, 1
        }, {
            101, 1
        }
    };
    private static byte LnxsubIdentity[] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 
        40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 
        50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 
        60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
        70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 
        80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 
        90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 
        100, 101
    };
    private static byte LnxqDigit_P[][] = {
        {
            1, 2, 3, 4, 5, 6, 7, 8, 9, 10
        }, {
            11, 12, 13, 14, 15, 16, 17, 18, 19, 20
        }, {
            21, 22, 23, 24, 25, 26, 27, 28, 29, 30
        }, {
            31, 32, 33, 34, 35, 36, 37, 38, 39, 40
        }, {
            41, 42, 43, 44, 45, 46, 47, 48, 49, 50
        }, {
            51, 52, 53, 54, 55, 56, 57, 58, 59, 60
        }, {
            61, 62, 63, 64, 65, 66, 67, 68, 69, 70
        }, {
            71, 72, 73, 74, 75, 76, 77, 78, 79, 80
        }, {
            81, 82, 83, 84, 85, 86, 87, 88, 89, 90
        }, {
            91, 92, 93, 94, 95, 96, 97, 98, 99, 100
        }
    };
    private static byte LnxqDigit_N[][] = {
        {
            101, 100, 99, 98, 97, 96, 95, 94, 93, 92
        }, {
            91, 90, 89, 88, 87, 86, 85, 84, 83, 82
        }, {
            81, 80, 79, 78, 77, 76, 75, 74, 73, 72
        }, {
            71, 70, 69, 68, 67, 66, 65, 64, 63, 62
        }, {
            61, 60, 59, 58, 57, 56, 55, 54, 53, 52
        }, {
            51, 50, 49, 48, 47, 46, 45, 44, 43, 42
        }, {
            41, 40, 39, 38, 37, 36, 35, 34, 33, 32
        }, {
            31, 30, 29, 28, 27, 26, 25, 24, 23, 22
        }, {
            21, 20, 19, 18, 17, 16, 15, 14, 13, 12
        }, {
            11, 10, 9, 8, 7, 6, 5, 4, 3, 2
        }
    };
    private static final double powerTable[][] = {
        {
            128D, 1E+256D, 9.9999999999999998E-257D
        }, {
            64D, 1.0000000000000001E+128D, 1.0000000000000001E-128D
        }, {
            32D, 1E+64D, 9.9999999999999997E-65D
        }, {
            16D, 1.0000000000000001E+32D, 1.0000000000000001E-32D
        }, {
            8D, 10000000000000000D, 9.9999999999999998E-17D
        }, {
            4D, 100000000D, 1E-08D
        }, {
            2D, 10000D, 0.0001D
        }, {
            1.0D, 100D, 0.01D
        }
    };
    private static final double factorTable[][] = {
        {
            15D, 1E+30D, 1.0000000000000001E-30D
        }, {
            14D, 9.9999999999999996E+27D, 9.9999999999999997E-29D
        }, {
            13D, 1E+26D, 1E-26D
        }, {
            12D, 9.9999999999999998E+23D, 9.9999999999999992E-25D
        }, {
            11D, 1E+22D, 1E-22D
        }, {
            10D, 1E+20D, 9.9999999999999995E-21D
        }, {
            9D, 1E+18D, 1.0000000000000001E-18D
        }, {
            8D, 10000000000000000D, 9.9999999999999998E-17D
        }, {
            7D, 100000000000000D, 1E-14D
        }, {
            6D, 1000000000000D, 9.9999999999999998E-13D
        }, {
            5D, 10000000000D, 1E-10D
        }, {
            4D, 100000000D, 1E-08D
        }, {
            3D, 1000000D, 9.9999999999999995E-07D
        }, {
            2D, 10000D, 0.0001D
        }, {
            1.0D, 100D, 0.01D
        }, {
            0, 1.0D, 1.0D
        }, {
            -1D, 0.01D, 100D
        }, {
            -2D, 0.0001D, 10000D
        }, {
            -3D, 9.9999999999999995E-07D, 1000000D
        }, {
            -4D, 1E-08D, 100000000D
        }, {
            -5D, 1E-10D, 10000000000D
        }, {
            -6D, 9.9999999999999998E-13D, 1000000000000D
        }, {
            -7D, 1E-14D, 100000000000000D
        }, {
            -8D, 9.9999999999999998E-17D, 10000000000000000D
        }, {
            -9D, 1.0000000000000001E-18D, 1E+18D
        }, {
            -10D, 9.9999999999999995E-21D, 1E+20D
        }, {
            -11D, 1E-22D, 1E+22D
        }, {
            -12D, 9.9999999999999992E-25D, 9.9999999999999998E+23D
        }, {
            -13D, 1E-26D, 1E+26D
        }, {
            -14D, 9.9999999999999997E-29D, 9.9999999999999996E+27D
        }, {
            -15D, 1.0000000000000001E-30D, 1E+30D
        }, {
            -16D, 1.0000000000000001E-32D, 1.0000000000000001E+32D
        }, {
            -17D, 9.9999999999999993E-35D, 9.9999999999999995E+33D
        }, {
            -18D, 9.9999999999999994E-37D, 1E+36D
        }, {
            -19D, 9.9999999999999996E-39D, 9.9999999999999998E+37D
        }, {
            -20D, 9.9999999999999993E-41D, 1E+40D
        }, {
            -21D, 1E-42D, 1E+42D
        }, {
            -22D, 9.9999999999999995E-45D, 1.0000000000000001E+44D
        }, {
            -23D, 1E-46D, 9.9999999999999999E+45D
        }, {
            -24D, 9.9999999999999997E-49D, 1E+48D
        }, {
            -25D, 1E-50D, 1.0000000000000001E+50D
        }, {
            -26D, 1E-52D, 9.9999999999999999E+51D
        }, {
            -27D, 1E-54D, 1.0000000000000001E+54D
        }, {
            -28D, 1E-56D, 1.0000000000000001E+56D
        }, {
            -29D, 1E-58D, 9.9999999999999994E+57D
        }, {
            -30D, 9.9999999999999997E-61D, 9.9999999999999995E+59D
        }, {
            -31D, 1E-62D, 1E+62D
        }, {
            -32D, 9.9999999999999997E-65D, 1E+64D
        }, {
            -33D, 9.9999999999999998E-67D, 9.9999999999999995E+65D
        }, {
            -34D, 1.0000000000000001E-68D, 9.9999999999999995E+67D
        }
    };
    private char lnx_chars[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
        '+', '-', ' ', '.', ',', '$', '<', '>', '(', ')', 
        '#', '~', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i', 
        'l', 'm', 'p', 'r', 's', 't', 'v', 'A', 'B', 'C', 
        'D', 'E', 'F', 'I', 'L', 'M', 'P', 'R', 'S', 'T'
    };

    // Decompiling method: <init>  Signature: ()V
    // Max stack: 5, #locals: 1, #params: 1
    // Code length: 332 bytes, Code offset: 41586
    // Line Number Table found: 109 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 332 Range 0 331 Init 0 fixed
    // RetValue   1 added: Name <returnValue> Type V At 0 332 Range 0 331 Init 0 fixed
    LnxLibThin()
    {
        super();
        /* LNXQNOSGN = 127; */
        /* LNXNFT_COMMA = ','; */
        /* LNXBYTEMASK = 255; */
        /* LNXSHORTMASK = 65535; */
        /* lnx_chars = (new char[] {
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
            '+', '-', ' ', '.', ',', '$', '<', '>', '(', ')', 
            '#', '~', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'i', 
            'l', 'm', 'p', 'r', 's', 't', 'v', 'A', 'B', 'C', 
            'D', 'E', 'F', 'I', 'L', 'M', 'P', 'R', 'S', 'T'
        }); */
        return;
    }

    // Decompiling method: LNXQH2N_DIGIT  Signature: (CIJ)J
    // Max stack: 4, #locals: 12, #params: 5
    // Code length: 92 bytes, Code offset: 42388
    // Line Number Table found: 27 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 92 Range 0 91 Init 0 fixed
    // Parameter  1 added: Name c Type C At 0 92 Range 0 91 Init 0
    // Parameter  2 added: Name i Type I At 0 92 Range 0 91 Init 0
    // Parameter  3 added: Name l Type J At 0 92 Range 0 91 Init 0
    // RetValue  12 added: Name <returnValue> Type J At 0 92 Range 0 91 Init 0 fixed
    // LocalVar   5 added: Name byte0 Type B At 2 2 Range 2 3 Init 2
    // LocalVar   6 added: Name byte1 Type B At 6 2 Range 6 7 Init 6
    // LocalVar   7 added: Name byte2 Type B At 10 2 Range 10 11 Init 10
    // LocalVar   8 added: Name byte3 Type B At 14 2 Range 14 15 Init 14
    // LocalVar   9 added: Name byte4 Type B At 18 2 Range 18 19 Init 18
    // LocalVar  10 added: Name l1 Type J At 44 4 Range 44 47 Init 44
    // LocalVar  10 added: Name l2 Type J At 73 4 Range 73 76 Init 73
    // LocalVar  10 added: Name l3 Type J At 87 4 Range 87 90 Init 87
    private long LNXQH2N_DIGIT(char c, int i, long l)
    {
        byte byte0 = 65;
        byte byte1 = 97;
        byte byte2 = 70;
        byte byte3 = 102;
        byte byte4 = 48;
        if(c >= 'a' && c <= 'f')
        {
            long l1 = l + (long)((c - 97) + 10 << i);
            return l1;
        }
        if(c >= 'A' && c <= 'F')
        {
            long l2 = l + (long)((c - 65) + 10 << i);
            return l2;
        } else
        {
            long l3 = l + (long)(c - 48 << i);
            return l3;
        }
    }

    // Decompiling method: LnxmulSetDigit1  Signature: ([BII)I
    // Max stack: 5, #locals: 5, #params: 3
    // Code length: 45 bytes, Code offset: 42622
    // Line Number Table found: 6 entries
    // Parameter  0 added: Name abyte0 Type [B At 0 45 Range 0 44 Init 0
    // Parameter  1 added: Name i Type I At 0 45 Range 0 44 Init 0
    // Parameter  2 added: Name j Type I At 0 45 Range 0 44 Init 0
    // RetValue   5 added: Name <returnValue> Type I At 0 45 Range 0 44 Init 0 fixed
    // LocalVar   3 added: Name k Type I At 4 28 Range 4 31 Init 4
    // LocalVar   4 added: Name l Type I At 10 34 Range 10 43 Init 10
    private static int LnxmulSetDigit1(byte abyte0[], int i, int j)
    {
        int k = j / 100;
        int l = j / 10000;
        i -= 2;
        abyte0[i + 1] = (byte)((j - k * 100) + 1);
        abyte0[i] = (byte)((k - l * 100) + 1);
        return l;
    }

    // Decompiling method: LnxmulSetDigit2  Signature: ([BII)V
    // Max stack: 5, #locals: 4, #params: 3
    // Code length: 30 bytes, Code offset: 42725
    // Line Number Table found: 5 entries
    // Parameter  0 added: Name abyte0 Type [B At 0 30 Range 0 29 Init 0
    // Parameter  1 added: Name i Type I At 0 30 Range 0 29 Init 0
    // Parameter  2 added: Name j Type I At 0 30 Range 0 29 Init 0
    // RetValue   4 added: Name <returnValue> Type V At 0 30 Range 0 29 Init 0 fixed
    // LocalVar   3 added: Name k Type I At 4 17 Range 4 20 Init 4
    private static void LnxmulSetDigit2(byte abyte0[], int i, int j)
    {
        int k = j / 100;
        i -= 2;
        abyte0[i] = (byte)(k + 1);
        abyte0[i + 1] = (byte)((j - k * 100) + 1);
        return;
    }

    // Decompiling method: LnxmulSetSum  Signature: ([I[IIIII)I
    // Max stack: 5, #locals: 6, #params: 6
    // Code length: 17 bytes, Code offset: 42809
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name ai Type [I At 0 17 Range 0 16 Init 0
    // Parameter  1 added: Name ai1 Type [I At 0 17 Range 0 16 Init 0
    // Parameter  2 added: Name i Type I At 0 17 Range 0 16 Init 0
    // Parameter  3 added: Name j Type I At 0 17 Range 0 16 Init 0
    // Parameter  4 added: Name k Type I At 0 17 Range 0 16 Init 0
    // Parameter  5 added: Name l Type I At 0 17 Range 0 16 Init 0
    // RetValue   6 added: Name <returnValue> Type I At 0 17 Range 0 16 Init 0 fixed
    private static int LnxmulSetSum(int ai[], int ai1[], int i, int j, int k, int l)
    {
        return l + ai[i - k] * ai1[j + k];
    }

    // Decompiling method: _negateNumber  Signature: ([B)V
    // Max stack: 5, #locals: 2, #params: 1
    // Code length: 35 bytes, Code offset: 42864
    // Line Number Table found: 5 entries
    // Parameter  0 added: Name abyte0 Type [B At 0 35 Range 0 34 Init 0
    // RetValue   2 added: Name <returnValue> Type V At 0 35 Range 0 34 Init 0 fixed
    // LocalVar   1 added: Name i Type I At 4 18 Range 4 21 Init 4
    private static void _negateNumber(byte abyte0[])
    {
        for(int i = abyte0.length - 1; i > 0; i--)
        {
            abyte0[i] = LnxqNegate[abyte0[i]];
        }

        abyte0[0] = (byte)(~abyte0[0]);
        return;
    }

    // Decompiling method: _setLength  Signature: ([BI)[B
    // Max stack: 5, #locals: 4, #params: 2
    // Code length: 60 bytes, Code offset: 42953
    // Line Number Table found: 12 entries
    // Parameter  0 added: Name abyte0 Type [B At 0 60 Range 0 59 Init 0
    // Parameter  1 added: Name i Type I At 0 60 Range 0 59 Init 0
    // RetValue   4 added: Name <returnValue> Type [B At 0 60 Range 0 59 Init 0 fixed
    // LocalVar   2 added: Name flag Type Z At 4 2 Range 4 5 Init 4
    // LocalVar   3 added: Name abyte1 Type [B At 12 47 Range 12 58 Init 12
    private static byte[] _setLength(byte abyte0[], int i)
    {
        boolean flag = NUMBER._isPositive(abyte0);
        byte abyte1[];
        if(flag)
        {
            abyte1 = new byte[i];
        } else
        if(i <= 20 && abyte0[i - 1] != 102)
        {
            abyte1 = new byte[i + 1];
            abyte1[i] = 102;
        } else
        {
            abyte1 = new byte[i];
        }
        System.arraycopy(abyte0, 0, abyte1, 0, i);
        return abyte1;
    }

    // Decompiling method: digitPtr  Signature: (IIZ)B
    // Max stack: 2, #locals: 3, #params: 3
    // Code length: 22 bytes, Code offset: 43095
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name i Type I At 0 22 Range 0 21 Init 0
    // Parameter  1 added: Name j Type I At 0 22 Range 0 21 Init 0
    // Parameter  2 added: Name flag Type Z At 0 22 Range 0 21 Init 0
    // RetValue   3 added: Name <returnValue> Type B At 0 22 Range 0 21 Init 0 fixed
    private static byte digitPtr(int i, int j, boolean flag)
    {
        return flag ? LnxqDigit_N[i][j] : LnxqDigit_P[i][j];
    }

    // Decompiling method: lnxabs  Signature: ([B)[B
    // Max stack: 5, #locals: 4, #params: 2
    // Code length: 71 bytes, Code offset: 43155
    // Line Number Table found: 12 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 71 Range 0 70 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 71 Range 0 70 Init 0
    // RetValue   4 added: Name <returnValue> Type [B At 0 71 Range 0 70 Init 0 fixed
    // LocalVar   2 added: Name abyte1 Type [B At 4 62 Range 4 65 Init 4
    // LocalVar   3 added: Name i Type I At 39 28 Range 39 66 Init 39
    public byte[] lnxabs(byte abyte0[])
        throws SQLException
    {
        byte abyte1[] = new byte[abyte0.length];
        if(NUMBER._isPositive(abyte0))
        {
            System.arraycopy(abyte0, 0, abyte1, 0, abyte0.length);
            return abyte1;
        }
        if(NUMBER._isNegInf(abyte0))
        {
            return NUMBER.posInf().shareBytes();
        }
        int i = abyte0.length;
        if(abyte0[i - 1] == 102)
        {
            i--;
        }
        System.arraycopy(abyte0, 0, abyte1, 0, i);
        _negateNumber(abyte1);
        return _setLength(abyte1, i);
    }

    // Decompiling method: lnxacos  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 43318
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxacos(byte abyte0[])
        throws SQLException
    {
        return lnxqtri(abyte0, 0);
    }

    // Decompiling method: lnxadd  Signature: ([B[B)[B
    // Max stack: 5, #locals: 43, #params: 3
    // Code length: 1941 bytes, Code offset: 43373
    // Line Number Table found: 305 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1941 Range 0 1940 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 1941 Range 0 1940 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 1941 Range 0 1940 Init 0
    // RetValue  43 added: Name <returnValue> Type [B At 0 1941 Range 0 1940 Init 0 fixed
    // LocalVar   3 added: Name i Type I At 2 304 Range 2 305 Init 2
    // LocalVar   4 added: Name flag Type Z At 4 987 Range 4 990 Init 4
    // LocalVar   5 added: Name j Type I At 8 256 Range 8 263 Init 8
    // LocalVar   6 added: Name flag1 Type Z At 11 970 Range 11 980 Init 11
    // LocalVar   7 added: Name abyte2 Type [B At 17 1918 Range 17 1934 Init 17
    // LocalVar   8 added: Name flag2 Type Z At 20 1891 Range 20 1910 Init 20
    // LocalVar  14 added: Name flag3 Type Z At 23 1255 Range 23 1277 Init 23
    // LocalVar  15 added: Name flag4 Type Z At 26 1255 Range 26 1280 Init 26
    // LocalVar  24 added: Name flag5 Type Z At 29 2 Range 29 30 Init 29
    // LocalVar  25 added: Name flag6 Type Z At 32 2 Range 32 33 Init 32
    // LocalVar  26 added: Name flag7 Type Z At 35 2 Range 35 36 Init 35
    // LocalVar   8 chged: Name k Oname flag2 Type I At 37 2 Range 20 1910 Init 20
    // LocalVar  18 added: Name l Type I At 41 1819 Range 41 1859 Init 41
    // LocalVar  27 added: Name flag2 Type Z At 47 961 Range 47 1007 Init 47
    // LocalVar  29 added: Name i1 Type I At 72 478 Range 72 549 Init 72
    // LocalVar  28 added: Name j1 Type I At 95 908 Range 95 1002 Init 95
    // LocalVar  30 added: Name flag8 Type Z At 101 764 Range 101 864 Init 101
    // LocalVar  32 added: Name k1 Type I At 126 659 Range 126 784 Init 126
    // LocalVar  31 added: Name l1 Type I At 151 832 Range 151 982 Init 151
    // LocalVar  33 added: Name flag9 Type Z At 176 4 Range 176 179 Init 176
    // LocalVar  33 added: Name flag10 Type Z At 214 4 Range 214 217 Init 214
    // LocalVar  33 added: Name flag11 Type Z At 260 2 Range 260 261 Init 260
    // LocalVar  38 added: Name i2 Type I At 264 6 Range 264 269 Init 264
    // LocalVar  33 added: Name flag12 Type Z At 303 2 Range 303 304 Init 303
    // LocalVar  38 added: Name j2 Type I At 306 6 Range 306 311 Init 306
    // LocalVar  23 added: Name k2 Type I At 321 708 Range 321 1028 Init 321
    // LocalVar  33 added: Name flag13 Type Z At 332 1581 Range 332 1912 Init 332
    // LocalVar   9 added: Name abyte3 Type [[B At 342 951 Range 342 1292 Init 342
    // LocalVar  36 added: Name flag14 Type Z At 345 1496 Range 345 1840 Init 345
    // LocalVar  37 added: Name flag15 Type Z At 348 1168 Range 348 1515 Init 348
    // LocalVar  36 chged: Name byte0 Oname flag14 Type B At 360 1481 Range 345 1840 Init 345
    // LocalVar  37 chged: Name byte1 Oname flag15 Type B At 363 1153 Range 348 1515 Init 348
    // LocalVar  42 added: Name l2 Type I At 370 130 Range 370 499 Init 370
    // LocalVar   4 chged: Name i3 Oname flag Type I At 377 2 Range 4 990 Init 4
    // LocalVar  39 added: Name j3 Type I At 381 89 Range 381 469 Init 381
    // LocalVar   6 chged: Name k3 Oname flag1 Type I At 383 2 Range 11 980 Init 11
    // LocalVar  40 added: Name l3 Type I At 387 87 Range 387 473 Init 387
    // LocalVar  41 added: Name i4 Type I At 406 36 Range 406 441 Init 406
    // LocalVar  34 added: Name j4 Type I At 550 1380 Range 550 1929 Init 550
    // LocalVar  24 added: Name k4 Type I At 564 810 Range 564 1373 Init 564
    // LocalVar  25 added: Name l4 Type I At 568 773 Range 568 1340 Init 568
    // LocalVar  26 added: Name i5 Type I At 578 497 Range 578 1074 Init 578
    // LocalVar  12 added: Name j5 Type I At 585 985 Range 585 1569 Init 585
    // LocalVar  13 added: Name flag Type Z At 588 954 Range 588 1541 Init 588
    // LocalVar  14 chged: Name k5 Oname flag3 Type I At 595 683 Range 23 1277 Init 23
    // LocalVar  15 chged: Name l5 Oname flag4 Type I At 602 679 Range 26 1280 Init 26
    // LocalVar  16 added: Name i6 Type I At 609 591 Range 609 1199 Init 609
    // LocalVar  17 added: Name flag1 Type Z At 612 560 Range 612 1171 Init 612
    // LocalVar  35 added: Name j6 Type I At 616 1265 Range 616 1880 Init 616
    // LocalVar  22 added: Name flag3 Type Z At 635 1102 Range 635 1736 Init 635
    // LocalVar  17 chged: Name byte2 Oname flag1 Type B At 697 475 Range 612 1171 Init 612
    // LocalVar  13 chged: Name byte3 Oname flag Type B At 828 714 Range 588 1541 Init 588
    // LocalVar  19 added: Name k6 Type I At 1060 778 Range 1060 1837 Init 1060
    // LocalVar  20 added: Name l6 Type I At 1064 511 Range 1064 1574 Init 1064
    // LocalVar  21 added: Name i7 Type I At 1076 131 Range 1076 1206 Init 1076
    // LocalVar  21 added: Name j7 Type I At 1220 68 Range 1220 1287 Init 1220
    // LocalVar  10 added: Name flag Type Z At 1223 20 Range 1223 1242 Init 1223
    // LocalVar  10 chged: Name k7 Oname flag Type I At 1230 2 Range 1223 1242 Init 1223
    // LocalVar  11 added: Name l7 Type I At 1239 18 Range 1239 1256 Init 1239
    // LocalVar  39 added: Name byte4 Type B At 1335 18 Range 1335 1352 Init 1335
    // LocalVar  21 added: Name i8 Type I At 1342 20 Range 1342 1361 Init 1342
    // LocalVar  21 added: Name j8 Type I At 1375 202 Range 1375 1576 Init 1375
    // LocalVar  39 added: Name k8 Type I At 1405 81 Range 1405 1485 Init 1405
    // LocalVar  40 added: Name l8 Type I At 1430 77 Range 1430 1506 Init 1430
    // LocalVar  39 added: Name byte5 Type B At 1733 33 Range 1733 1765 Init 1733
    // LocalVar  36 chged: Name i9 Oname byte0 Type I At 1746 2 Range 345 1840 Init 345
    // LocalVar  39 added: Name abyte4 Type [B At 1854 16 Range 1854 1869 Init 1854
    // LocalVar  38 added: Name j9 Type I At 1883 54 Range 1883 1936 Init 1883
    // LocalVar  39 chged: Name k9 Oname byte4 Type I At 1335 2 Range 1335 1352 Init 1335
    // LocalVar  24 chged: Name l9 Oname flag5 Type I At 29 2 Range 29 30 Init 29
    // LocalVar  24 name k4(I) merged out into l9(I)
    // LocalVar  25 chged: Name k4 Oname flag6 Type I At 32 2 Range 32 33 Init 32
    // LocalVar  25 name l4(I) merged out into k4(I)
    // LocalVar  26 chged: Name l4 Oname flag7 Type I At 35 2 Range 35 36 Init 35
    // LocalVar  26 name i5(I) merged out into l4(I)
    public byte[] lnxadd(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        int i = abyte0.length;
        int j = 0;
        int k = abyte1.length;
        int l = 0;
        byte abyte2[] = new byte[41];
        int i1 = 0;
        int i2 = 0;
        int j2 = 0;
        int l4 = 0;
        int i5 = 0;
        int j5 = 0;
        int l2 = i1 + 1;
        boolean flag1 = NUMBER._isPositive(abyte0);
        int l5 = abyte0[0] >= 0 ? 255 - abyte0[0] : 256 + abyte0[0];
        if(!flag1 && abyte0[i - 1] == 102)
        {
            i--;
        }
        int k5 = i - 1;
        boolean flag2 = NUMBER._isPositive(abyte1);
        int j6 = abyte1[0] >= 0 ? 255 - abyte1[0] : 256 + abyte1[0];
        if(!flag2 && abyte1[k - 1] == 102)
        {
            k--;
        }
        int i6 = k - 1;
        if(l5 == 255 && (k5 == 0 || abyte0[1] == 101))
        {
            boolean flag3 = flag1;
            if(flag3)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if(j6 == 255 && (i6 == 0 || abyte1[1] == 101))
        {
            boolean flag4 = flag2;
            if(flag4)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if(l5 == 128 && k5 == 0)
        {
            abyte2 = new byte[k];
            System.arraycopy(abyte1, 0, abyte2, 0, k);
            boolean flag5 = flag2;
            int j7 = k;
            return _setLength(abyte2, j7);
        }
        if(j6 == 128 && i6 == 0)
        {
            abyte2 = new byte[i];
            System.arraycopy(abyte0, 0, abyte2, 0, i);
            boolean flag6 = flag1;
            int k7 = i;
            return _setLength(abyte2, k7);
        }
        int k4 = l5 - j6;
        byte abyte3[][];
        boolean flag7;
        int i7;
        byte byte2;
        if(flag1 == flag2)
        {
            flag7 = flag1;
            if(flag7)
            {
                abyte3 = LnxqAdd_PPP;
                i7 = 1;
                byte2 = 1;
            } else
            {
                abyte3 = LnxqAdd_NNN;
                i7 = 101;
                byte2 = -1;
            }
        } else
        {
            int k9 = k4;
            if(k9 == 0)
            {
                int i8 = j + 1;
                int l8 = l + 1;
                int j9;
                for(j9 = j + (k5 >= i6 ? i6 : k5); i8 <= j9 && abyte0[i8] + abyte1[l8] == 102; l8++)
                {
                    i8++;
                }

                if(i8 <= j9)
                {
                    k9 = flag1 ? (abyte0[i8] + abyte1[l8]) - 102 : 102 - (abyte0[i8] + abyte1[l8]);
                } else
                {
                    k9 = k5 - i6;
                }
            }
            if(k9 == 0)
            {
                return NUMBER._makeZero();
            }
            flag7 = k9 <= 0 ? flag2 : flag1;
            if(flag7)
            {
                abyte3 = LnxqAdd_PNP;
                i7 = 1;
                byte2 = -1;
            } else
            {
                abyte3 = LnxqAdd_PNN;
                i7 = 101;
                byte2 = 1;
            }
        }
        int l1;
        byte byte0;
        int k2;
        byte byte1;
        boolean flag;
        int k6;
        int l6;
        if(k4 >= 0)
        {
            k6 = l5;
            if(k4 + i6 <= k5)
            {
                l4 = k4;
                i5 = i6;
                j5 = k5 - (k4 + i6);
                l1 = j + l4;
                byte0 = 1;
                i2 = l1 + i5;
                j2 = l + i6;
                k2 = j + k5;
                byte1 = 1;
                l6 = k5;
                flag = j5 != 0 && flag1 != flag7;
            } else
            if(k4 < k5)
            {
                l4 = k4;
                i5 = k5 - k4;
                j5 = i6 - i5;
                l1 = j + l4;
                byte0 = 1;
                i2 = j + k5;
                j2 = l + i5;
                k2 = l + i6;
                byte1 = 2;
                l6 = k4 + i6;
                flag = flag2 != flag7;
            } else
            {
                l4 = k5;
                i5 = -(k4 - k5);
                j5 = i6;
                l1 = j + k5;
                byte0 = 1;
                k2 = l + i6;
                byte1 = 2;
                l6 = k4 + i6;
                flag = flag2 != flag7;
            }
        } else
        {
            k6 = j6;
            k4 = -k4;
            if(k4 + k5 <= i6)
            {
                l4 = k4;
                i5 = k5;
                j5 = i6 - (k4 + k5);
                l1 = l + l4;
                byte0 = 2;
                i2 = j + k5;
                j2 = l1 + i5;
                k2 = l + i6;
                byte1 = 2;
                l6 = i6;
                flag = j5 != 0 && flag2 != flag7;
            } else
            if(k4 < i6)
            {
                l4 = k4;
                i5 = i6 - k4;
                j5 = k5 - i5;
                l1 = l + l4;
                byte0 = 2;
                i2 = j + i5;
                j2 = l + i6;
                k2 = j + k5;
                byte1 = 1;
                l6 = k4 + k5;
                flag = flag1 != flag7;
            } else
            {
                l4 = i6;
                i5 = -(k4 - i6);
                j5 = k5;
                l1 = l + i6;
                byte0 = 2;
                k2 = j + k5;
                byte1 = 1;
                l6 = k4 + k5;
                flag = flag1 != flag7;
            }
        }
        if(l6 > 20)
        {
            if(k4 > 20)
            {
                i5 = 0;
                j5 = 0;
                l6 = l4;
                flag = false;
            } else
            {
                l2 = 1;
            }
        }
        int i3 = l2 + (l6 - 1);
        int j3 = i3;
        if(j5 != 0)
        {
            int k3 = j3 - j5;
            if(byte1 == 1)
            {
                abyte2[j3] = abyte0[k2];
            } else
            {
                abyte2[j3] = abyte1[k2];
            }
            k2--;
            j3--;
            if(flag)
            {
                for(; j3 > k3; j3--)
                {
                    if(byte1 == 1)
                    {
                        abyte2[j3] = (byte)(abyte0[k2] + byte2);
                    } else
                    {
                        abyte2[j3] = (byte)(abyte1[k2] + byte2);
                    }
                    k2--;
                }

            } else
            {
                for(; j3 > k3; j3--)
                {
                    if(byte1 == 1)
                    {
                        abyte2[j3] = abyte0[k2];
                    } else
                    {
                        abyte2[j3] = abyte1[k2];
                    }
                    k2--;
                }

            }
        }
        if(i5 > 0)
        {
            int l3 = j3 - i5;
            int j1 = 0;
            int k1 = flag ? j1 + 1 : j1;
            do
            {
                k1 = j1 + abyte0[i2] + abyte1[j2] + abyte3[k1][1];
                abyte2[j3] = abyte3[k1][0];
                i2--;
                j2--;
            } while(--j3 > l3);
            flag = (abyte3[k1][1] & 0x1) != 0;
        } else
        {
            int j8 = flag ? byte2 != 1 ? 100 : 2 : i7;
            for(int i4 = j3 + i5; j3 > i4; j3--)
            {
                abyte2[j3] = (byte)j8;
            }

        }
        if(l4 != 0)
        {
            int j4 = j3 - l4;
            if(flag)
            {
                int k8 = (byte2 != 1 ? 1 : 100) + (flag7 ? 0 : 1);
                int i9 = (byte2 != 1 ? 100 : 1) + (flag7 ? 0 : 1);
                do
                {
                    if(byte0 == 1)
                    {
                        flag = abyte0[l1] == k8;
                        abyte2[j3] = (byte)(flag ? i9 : abyte0[l1] + byte2);
                    } else
                    {
                        flag = abyte1[l1] == k8;
                        abyte2[j3] = (byte)(flag ? i9 : abyte1[l1] + byte2);
                    }
                    l1--;
                    j3--;
                } while(flag && j3 > j4);
            }
            for(; j3 > j4; j3--)
            {
                if(byte0 == 1)
                {
                    abyte2[j3] = abyte0[l1];
                } else
                {
                    abyte2[j3] = abyte1[l1];
                }
                l1--;
            }

        }
        if(flag)
        {
            if(k6 == 255)
            {
                if(flag7)
                {
                    return NUMBER._makePosInf();
                } else
                {
                    return NUMBER._makeNegInf();
                }
            }
            l2--;
            abyte2[l2] = (byte)(flag7 ? 2 : 100);
            k6++;
            l6++;
        }
        if(abyte2[l2] == i7)
        {
            do
            {
                l2++;
                k6--;
                l6--;
            } while(abyte2[l2] == i7);
            if(k6 < 128)
            {
                return NUMBER._makeZero();
            }
        }
        if(l6 > 20)
        {
            i3 = l2 + 19;
            l6 = 20;
            if((flag7 ? abyte2[i3 + 1] : LnxqNegate[abyte2[i3 + 1]]) > 50)
            {
                byte byte3 = flag7 ? ((byte) (100)) : 2;
                if(!flag)
                {
                    abyte2[l2 - 1] = (byte)i7;
                }
                while(abyte2[i3] == byte3) 
                {
                    i3--;
                    l6--;
                }
                if(i3 < l2)
                {
                    if(k6 == 255)
                    {
                        if(flag7)
                        {
                            return NUMBER._makePosInf();
                        } else
                        {
                            return NUMBER._makeNegInf();
                        }
                    }
                    l2--;
                    k6++;
                    l6 = 1;
                }
                abyte2[i3] += flag7 ? 1 : -1;
            }
        }
        while(abyte2[i3] == i7) 
        {
            i3--;
            l6--;
        }
        if(l2 != 1)
        {
            byte abyte4[] = new byte[41];
            System.arraycopy(abyte2, l2, abyte4, 1, l6);
            System.arraycopy(abyte4, 1, abyte2, 1, l6);
        }
        int l7 = l6 + 1;
        if(!flag7 && l7 <= 20)
        {
            abyte2[l7] = 102;
            l7++;
        }
        abyte2[i1] = (byte)(flag7 ? k6 - 256 : 255 - k6);
        return _setLength(abyte2, l7);
    }

    // Decompiling method: lnxasin  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 46578
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxasin(byte abyte0[])
        throws SQLException
    {
        return lnxqtri(abyte0, 1);
    }

    // Decompiling method: lnxatan  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 46633
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxatan(byte abyte0[])
        throws SQLException
    {
        return lnxqtri(abyte0, 2);
    }

    // Decompiling method: lnxatan2  Signature: ([B[B)[B
    // Max stack: 3, #locals: 5, #params: 3
    // Code length: 80 bytes, Code offset: 46688
    // Line Number Table found: 12 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 80 Range 0 79 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 80 Range 0 79 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 80 Range 0 79 Init 0
    // RetValue   5 added: Name <returnValue> Type [B At 0 80 Range 0 79 Init 0 fixed
    // LocalVar   3 added: Name abyte2 Type [B At 33 3 Range 33 35 Init 33
    // LocalVar   3 added: Name abyte3 Type [B At 39 35 Range 39 73 Init 39
    // LocalVar   4 added: Name abyte4 Type [B At 55 21 Range 55 75 Init 55
    // LocalVar   3 name abyte3([B) merged out into abyte2([B)
    public byte[] lnxatan2(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        if(NUMBER._isZero(abyte0) && NUMBER._isZero(abyte1))
        {
            throw new SQLException(CoreException.getMessage((byte)11));
        }
        byte abyte2[] = lnxdiv(abyte0, abyte1);
        abyte2 = lnxatan(abyte2);
        if(NUMBER._isPositive(abyte1))
        {
            return abyte2;
        }
        byte abyte3[] = NUMBER.pi().shareBytes();
        if(NUMBER._isPositive(abyte0))
        {
            return lnxadd(abyte2, abyte3);
        } else
        {
            return lnxsub(abyte2, abyte3);
        }
    }

    // Decompiling method: lnxbex  Signature: ([B[B)[B
    // Max stack: 5, #locals: 4, #params: 3
    // Code length: 151 bytes, Code offset: 46860
    // Line Number Table found: 19 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 151 Range 0 150 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 151 Range 0 150 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 151 Range 0 150 Init 0
    // RetValue   4 added: Name <returnValue> Type [B At 0 151 Range 0 150 Init 0 fixed
    // LocalVar   3 added: Name abyte2 Type [B At 37 4 Range 37 40 Init 37
    // LocalVar   3 added: Name abyte3 Type [B At 44 3 Range 44 46 Init 44
    // LocalVar   3 added: Name abyte4 Type [B At 64 15 Range 64 78 Init 64
    // LocalVar   3 added: Name abyte5 Type [B At 103 3 Range 103 105 Init 103
    // LocalVar   3 added: Name abyte6 Type [B At 109 4 Range 109 112 Init 109
    // LocalVar   3 added: Name abyte7 Type [B At 116 3 Range 116 118 Init 116
    // LocalVar   3 added: Name abyte8 Type [B At 122 22 Range 122 143 Init 122
    // LocalVar   3 name abyte3([B) merged out into abyte2([B)
    // LocalVar   3 name abyte6([B) merged out into abyte5([B)
    // LocalVar   3 name abyte7([B) merged out into abyte5([B)
    // LocalVar   3 name abyte8([B) merged out into abyte5([B)
    public byte[] lnxbex(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        switch(lnxsgn(abyte0))
        {
        case 1: // '\001'
            byte abyte2[] = lnxln(abyte0);
            abyte2 = lnxmul(abyte1, abyte2);
            return lnxexp(abyte2);

        case 0: // '\0'
            if(NUMBER._isZero(abyte1))
            {
                byte abyte3[] = new byte[lnxqone.length];
                System.arraycopy(lnxqone, 0, abyte3, 0, lnxqone.length);
                return abyte3;
            } else
            {
                return NUMBER._makeZero();
            }

        case -1: 
            if((new NUMBER(abyte1)).isInt())
            {
                byte abyte4[] = lnxneg(abyte0);
                abyte4 = lnxln(abyte4);
                abyte4 = lnxmul(abyte1, abyte4);
                abyte4 = lnxexp(abyte4);
                if(!NUMBER._isZero(lnxmod(abyte1, lnxqtwo)))
                {
                    abyte4 = lnxneg(abyte4);
                }
                return abyte4;
            } else
            {
                return NUMBER._makePosInf();
            }
        }
        return null;
    }

    // Decompiling method: lnxceil  Signature: ([B)[B
    // Max stack: 3, #locals: 3, #params: 2
    // Code length: 33 bytes, Code offset: 47131
    // Line Number Table found: 4 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 33 Range 0 32 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 33 Range 0 32 Init 0
    // RetValue   3 added: Name <returnValue> Type [B At 0 33 Range 0 32 Init 0 fixed
    // LocalVar   2 added: Name abyte1 Type [B At 6 26 Range 6 31 Init 6
    public byte[] lnxceil(byte abyte0[])
        throws SQLException
    {
        byte abyte1[] = lnxtru(abyte0, 0);
        if(Datum.compareBytes(abyte1, abyte0) != 0 && NUMBER._isPositive(abyte0))
        {
            abyte1 = lnxadd(abyte1, lnxqone);
        }
        return abyte1;
    }

    // Decompiling method: lnxcmp  Signature: ([B[B)I
    // Max stack: 2, #locals: 3, #params: 3
    // Code length: 6 bytes, Code offset: 47224
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 6 Range 0 5 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 6 Range 0 5 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 6 Range 0 5 Init 0
    // RetValue   3 added: Name <returnValue> Type I At 0 6 Range 0 5 Init 0 fixed
    private int lnxcmp(byte abyte0[], byte abyte1[])
    {
        return Datum.compareBytes(abyte0, abyte1);
    }

    // Decompiling method: lnxcos  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 47268
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxcos(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 3);
    }

    // Decompiling method: lnxcpn  Signature: (Ljava/lang/String;ZIZILjava/lang/String;)[B
    // Max stack: 6, #locals: 47, #params: 7
    // Code length: 1668 bytes, Code offset: 47323
    // Line Number Table found: 241 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1668 Range 0 1667 Init 0 fixed
    // Parameter  1 added: Name s Type Ljava/lang/String; At 0 1668 Range 0 1667 Init 0
    // Parameter  2 added: Name flag Type Z At 0 1668 Range 0 1667 Init 0
    // Parameter  3 added: Name i Type I At 0 1668 Range 0 1667 Init 0
    // Parameter  4 added: Name flag1 Type Z At 0 1668 Range 0 1667 Init 0
    // Parameter  5 added: Name j Type I At 0 1668 Range 0 1667 Init 0
    // Parameter  6 added: Name s1 Type Ljava/lang/String; At 0 1668 Range 0 1667 Init 0
    // RetValue  47 added: Name <returnValue> Type [B At 0 1668 Range 0 1667 Init 0 fixed
    // LocalVar  12 added: Name flag2 Type Z At 1 743 Range 1 743 Init 1
    // LocalVar  16 added: Name flag3 Type Z At 4 724 Range 4 727 Init 4
    // LocalVar  17 added: Name flag4 Type Z At 7 1639 Range 7 1645 Init 7
    // LocalVar  18 added: Name flag5 Type Z At 10 1301 Range 10 1310 Init 10
    // LocalVar  19 added: Name flag6 Type Z At 13 2 Range 13 14 Init 13
    // LocalVar  20 added: Name flag7 Type Z At 16 2 Range 16 17 Init 16
    // LocalVar  21 added: Name flag8 Type Z At 19 390 Range 19 408 Init 19
    // LocalVar  22 added: Name flag9 Type Z At 22 718 Range 22 739 Init 22
    // LocalVar  23 added: Name flag10 Type Z At 25 2 Range 25 26 Init 25
    // LocalVar  24 added: Name flag11 Type Z At 28 1288 Range 28 1315 Init 28
    // LocalVar  28 added: Name flag12 Type Z At 31 1402 Range 31 1432 Init 31
    // LocalVar  29 added: Name flag13 Type Z At 34 1404 Range 34 1437 Init 34
    // LocalVar  30 added: Name flag14 Type Z At 37 1310 Range 37 1346 Init 37
    // LocalVar  31 added: Name flag15 Type Z At 40 1552 Range 40 1591 Init 40
    // LocalVar  41 added: Name flag16 Type Z At 43 1049 Range 43 1091 Init 43
    // LocalVar  43 added: Name k Type I At 57 39 Range 57 95 Init 57
    // LocalVar  44 added: Name nlslocale Type Loracle/gss/util/NLSLocale; At 62 43 Range 62 104 Init 62
    // LocalVar  42 added: Name locale Type Ljava/util/Locale; At 77 61 Range 77 137 Init 77
    // LocalVar  45 added: Name s2 Type Ljava/lang/String; At 90 17 Range 90 106 Init 90
    // LocalVar  46 added: Name s3 Type Ljava/lang/String; At 101 8 Range 101 108 Init 101
    // LocalVar  43 added: Name decimalformatsymbols Type Ljava/text/DecimalFormatSymbols; At 141 11 Range 141 151 Init 141
    // LocalVar  35 added: Name c Type C At 148 811 Range 148 958 Init 148
    // LocalVar  40 added: Name c1 Type C At 155 322 Range 155 476 Init 155
    // LocalVar   7 added: Name ac Type [C At 161 1387 Range 161 1547 Init 161
    // LocalVar   9 added: Name flag17 Type Z At 164 443 Range 164 606 Init 164
    // LocalVar  10 added: Name l Type I At 171 429 Range 171 599 Init 171
    // LocalVar   9 chged: Name i1 Oname flag17 Type I At 179 2 Range 164 606 Init 164
    // LocalVar   8 added: Name j1 Type I At 246 57 Range 246 302 Init 246
    // LocalVar  11 added: Name k1 Type I At 273 423 Range 273 695 Init 273
    // LocalVar  19 added: Name l1 Type I At 304 103 Range 304 406 Init 304
    // LocalVar  20 added: Name i2 Type I At 311 350 Range 311 660 Init 311
    // LocalVar  12 chged: Name j2 Oname flag2 Type I At 335 409 Range 1 743 Init 1
    // LocalVar  21 chged: Name k2 Oname flag8 Type I At 366 43 Range 19 408 Init 19
    // LocalVar   8 added: Name l2 Type I At 370 33 Range 370 402 Init 370
    // LocalVar  22 chged: Name i3 Oname flag9 Type I At 399 341 Range 22 739 Init 22
    // LocalVar   8 added: Name j3 Type I At 492 73 Range 492 564 Init 492
    // LocalVar  13 added: Name k3 Type I At 519 53 Range 519 571 Init 519
    // LocalVar  23 added: Name l3 Type I At 566 11 Range 566 576 Init 566
    // LocalVar  24 chged: Name i4 Oname flag11 Type I At 573 743 Range 28 1315 Init 28
    // LocalVar  16 chged: Name j4 Oname flag3 Type I At 585 2 Range 4 727 Init 4
    // LocalVar  32 added: Name k4 Type I At 635 749 Range 635 1383 Init 635
    // LocalVar  33 added: Name l4 Type I At 639 851 Range 639 1489 Init 639
    // LocalVar  15 added: Name i5 Type I At 643 700 Range 643 1342 Init 643
    // LocalVar   9 added: Name j5 Type I At 664 20 Range 664 683 Init 664
    // LocalVar   9 added: Name k5 Type I At 708 45 Range 708 752 Init 708
    // LocalVar  27 added: Name byte0 Type B At 777 53 Range 777 829 Init 777
    // LocalVar  25 added: Name l5 Type I At 784 82 Range 784 865 Init 784
    // LocalVar  26 added: Name i6 Type I At 817 11 Range 817 827 Init 817
    // LocalVar  26 added: Name j6 Type I At 833 43 Range 833 875 Init 833
    // LocalVar  34 added: Name flag2 Type Z At 860 709 Range 860 1568 Init 860
    // LocalVar   9 added: Name k6 Type I At 887 196 Range 887 1082 Init 887
    // LocalVar  39 added: Name abyte0 Type [B At 1336 326 Range 1336 1661 Init 1336
    // LocalVar  38 added: Name flag3 Type Z At 1339 300 Range 1339 1638 Init 1339
    // LocalVar   9 added: Name l6 Type I At 1343 224 Range 1343 1566 Init 1343
    // LocalVar  38 chged: Name i7 Oname flag3 Type I At 1352 2 Range 1339 1638 Init 1339
    // LocalVar  14 added: Name j7 Type I At 1385 43 Range 1385 1427 Init 1385
    // LocalVar  14 added: Name k7 Type I At 1491 43 Range 1491 1533 Init 1491
    // LocalVar  37 added: Name byte1 Type B At 1621 37 Range 1621 1657 Init 1621
    // LocalVar  36 added: Name l7 Type I At 1639 25 Range 1639 1663 Init 1639
    // LocalVar   9 name l6(I) merged out into i1(I)
    // LocalVar   9 name j5(I) merged out into i1(I)
    // LocalVar   9 name k5(I) merged out into i1(I)
    // LocalVar   9 name k6(I) merged out into i1(I)
    // LocalVar  19 chged: Name j5 Oname flag6 Type I At 13 2 Range 13 14 Init 13
    // LocalVar  19 name l1(I) merged out into j5(I)
    // LocalVar  20 chged: Name l1 Oname flag7 Type I At 16 2 Range 16 17 Init 16
    // LocalVar  20 name i2(I) merged out into l1(I)
    // LocalVar  26 name j6(I) merged out into i6(I)
    public byte[] lnxcpn(String s, boolean flag, int i, boolean flag1, int j, String s1)
        throws SQLException
    {
        int i2 = 0;
        int j3 = 0;
        boolean flag2 = false;
        boolean flag3 = false;
        int k3 = 0;
        int l3 = 0;
        int i4 = 0;
        int j4 = 0;
        boolean flag4 = false;
        int l4 = 0;
        boolean flag5 = false;
        boolean flag6 = false;
        boolean flag7 = false;
        boolean flag8 = false;
        boolean flag10 = false;
        Locale locale;
        if(s1 != null)
        {
            int k6 = s1.indexOf("_");
            NLSLocale nlslocale = NLSLocale.getInstance();
            if(k6 == -1)
            {
                locale = nlslocale.getJavaLocale(s1);
            } else
            {
                String s2 = s1.substring(0, k6);
                String s3 = s1.substring(k6 + 1);
                locale = nlslocale.getJavaLocale(s2, s3);
            }
            if(locale == null)
            {
                locale = Locale.getDefault();
            }
        } else
        {
            locale = Locale.getDefault();
        }
        DecimalFormatSymbols decimalformatsymbols = new DecimalFormatSymbols(locale);
        char c = decimalformatsymbols.getDecimalSeparator();
        char c1 = decimalformatsymbols.getMinusSign();
        char ac[] = s.toCharArray();
        int j1 = 0;
        int k1;
        for(k1 = ac.length - 1; j1 <= k1 && Character.isSpaceChar(ac[j1]); j1++) { }
        if(j1 <= k1 && (ac[j1] == c1 || ac[j1] == '+'))
        {
            flag2 = ac[j1] == c1;
            j1++;
        }
        int k = j1;
        for(; j1 <= k1 && ac[j1] == '0'; j1++) { }
        int l1 = j1;
        for(; j1 <= k1 && Character.isDigit(ac[j1]); j1++) { }
        k3 = j1 - k;
        l3 = j1 - l1;
        if(j1 <= k1 && ac[j1] == c)
        {
            i2 = ++j1;
            for(; j1 <= k1 && Character.isDigit(ac[j1]); j1++) { }
            i4 = j1 - i2;
            int l = j1;
            while(--j1 >= i2 && ac[j1] == '0') ;
            j4 = (j1 - i2) + 1;
            j1 = l;
        }
        if(k3 + i4 != 0)
        {
            if(j1 <= k1 && (ac[j1] == 'E' || ac[j1] == 'e'))
            {
                if(++j1 <= k1 && (ac[j1] == c1 || ac[j1] == '+'))
                {
                    flag3 = ac[j1] == c1;
                    j1++;
                }
                int i1 = j1;
                for(; j1 <= k1 && ac[j1] == '0'; j1++) { }
                int j2 = j1;
                for(; j1 <= k1 && Character.isDigit(ac[j1]); j1++)
                {
                    j3 = j3 * 10 + (ac[j1] - 48);
                }

                int k4 = j1 - i1;
                l4 = j1 - j2;
                if(k4 != 0 && flag3)
                {
                    j3 = -j3;
                }
            }
            for(; j1 <= k1 && Character.isSpaceChar(ac[j1]); j1++) { }
        }
        int i3;
        int k5;
        int l5;
        if(l3 != 0)
        {
            if(j4 != 0)
            {
                j3 += l3 - 1;
                k5 = l3;
                l5 = j4;
                i3 = l1;
            } else
            {
                j3 += l3 - 1;
                for(j1 = l1 + (l3 - 1); ac[j1] == '0'; j1--) { }
                k5 = (j1 - l1) + 1;
                l5 = 0;
                i3 = l1;
            }
        } else
        if(j4 != 0)
        {
            for(j1 = i2; ac[j1] == '0'; j1++) { }
            j3 -= (j1 - i2) + 1;
            k5 = j4 - (j1 - i2);
            l5 = 0;
            i3 = j1;
        } else
        {
            return NUMBER._makeZero();
        }
        byte byte0 = (j3 & 0x1) != 1 ? ((byte) (39)) : 40;
        int i5 = k5 + l5;
        int j5;
        if(flag || flag1)
        {
            if(!flag)
            {
                i = 0x7fffffff;
            }
            if(!flag1)
            {
                j = 0;
            }
            j5 = j3 + 1 + j;
        } else
        {
            j5 = i5;
        }
        j5 = Math.min(j5, byte0);
        if(j5 < 0 || j5 == 0 && ac[i3] < '5')
        {
            return NUMBER._makeZero();
        }
        boolean flag9 = false;
        if(j5 < i5)
        {
            j1 = i3 + j5 + (j5 >= k5 ? 1 : 0);
            if(ac[j1] < '5')
            {
                while(--j1 >= i3 && (ac[j1] == '0' || ac[j1] == c)) ;
            } else
            {
                while(--j1 >= i3 && (ac[j1] == '9' || ac[j1] == c)) ;
                flag9 = true;
            }
            if(j1 < i3)
            {
                ac[1] = '1';
                ac[2] = '0';
                i3 = 1;
                j3++;
                flag5 = false;
                flag7 = (j3 & 0x1) != 1;
                flag8 = false;
                k5 = (j3 & 0x1) != 1 ? 0 : 2;
                l5 = 0;
                flag9 = false;
                flag10 = true;
            } else
            if(l5 != 0)
            {
                if(j1 - i3 < k5)
                {
                    k5 = (j1 - i3) + 1;
                    l5 = 0;
                } else
                {
                    l5 = j1 - i3 - k5;
                }
            } else
            {
                k5 = (j1 - i3) + 1;
            }
        }
        if(!flag10)
        {
            if(l5 != 0)
            {
                flag5 = true;
                flag6 = (j3 & 0x1) == (k5 & 0x1);
                flag7 = (j3 & 0x1) != 1;
                flag8 = flag6 != ((l5 & 0x1) == 1);
                k5 -= (flag7 ? 1 : 0) + (flag6 ? 1 : 0);
                l5 -= (flag6 ? 1 : 0) + (flag8 ? 1 : 0);
            } else
            {
                flag5 = false;
                flag7 = (j3 & 0x1) != 1;
                flag8 = (j3 & 0x1) == (k5 & 0x1);
                k5 -= (flag7 ? 1 : 0) + (flag8 ? 1 : 0);
            }
        }
        if(!flag3 && (l4 > 3 || j3 > 125))
        {
            if(flag2)
            {
                return NUMBER._makeNegInf();
            } else
            {
                return NUMBER._makePosInf();
            }
        }
        if(flag3 && (l4 > 3 || j3 < -130))
        {
            return NUMBER._makeZero();
        }
        byte abyte0[] = new byte[22];
        int j6 = 1;
        j1 = i3;
        if(flag7)
        {
            abyte0[j6] = digitPtr(0, lnxqctn(ac[j1]), flag2);
            j6++;
            j1++;
        }
        if(k5 != 0)
        {
            for(int k2 = j1 + k5; j1 < k2; j1 += 2)
            {
                abyte0[j6] = digitPtr(lnxqctn(ac[j1]), lnxqctn(ac[j1 + 1]), flag2);
                j6++;
            }

        }
        if(flag5)
        {
            if(flag6)
            {
                abyte0[j6] = digitPtr(lnxqctn(ac[j1]), lnxqctn(ac[j1 + 2]), flag2);
                j6++;
                j1 += 3;
            } else
            {
                j1++;
            }
        }
        if(l5 != 0)
        {
            for(int l2 = j1 + l5; j1 < l2; j1 += 2)
            {
                abyte0[j6] = digitPtr(lnxqctn(ac[j1]), lnxqctn(ac[j1 + 1]), flag2);
                j6++;
            }

        }
        if(flag8)
        {
            abyte0[j6] = digitPtr(lnxqctn(ac[j1]), 0, flag2);
            j6++;
            j1++;
        }
        if(flag9)
        {
            abyte0[j6 - 1] += (flag2 ? -1 : 1) * (flag8 ? 10 : 1);
        }
        byte byte1;
        if(j3 < 0)
        {
            byte1 = (byte)(193 - (1 - j3) / 2);
        } else
        {
            byte1 = (byte)(193 + j3 / 2);
        }
        int i6 = j6;
        abyte0[0] = (byte)(flag2 ? ~byte1 : byte1);
        return _setLength(abyte0, i6);
    }

    // Decompiling method: lnxcsh  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 8 bytes, Code offset: 49999
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 8 Range 0 7 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 8 Range 0 7 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 8 Range 0 7 Init 0 fixed
    public byte[] lnxcsh(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 6);
    }

    // Decompiling method: lnxdec  Signature: ([B)[B
    // Max stack: 5, #locals: 8, #params: 2
    // Code length: 213 bytes, Code offset: 50055
    // Line Number Table found: 30 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 213 Range 0 212 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 213 Range 0 212 Init 0
    // RetValue   8 added: Name <returnValue> Type [B At 0 213 Range 0 212 Init 0 fixed
    // LocalVar   5 added: Name i Type I At 2 201 Range 2 202 Init 2
    // LocalVar   6 added: Name abyte1 Type [B At 8 189 Range 8 196 Init 8
    // LocalVar   2 added: Name byte0 Type B At 40 138 Range 40 177 Init 40
    // LocalVar   3 added: Name j Type I At 54 72 Range 54 125 Init 54
    // LocalVar   4 added: Name k Type I At 59 69 Range 59 127 Init 59
    // LocalVar   7 added: Name flag Type Z At 140 22 Range 140 161 Init 140
    // LocalVar   7 chged: Name l Oname flag Type I At 160 2 Range 140 161 Init 140
    // LocalVar   2 chged: Name i1 Oname byte0 Type I At 166 3 Range 40 177 Init 40
    // LocalVar   7 added: Name abyte2 Type [B At 193 15 Range 193 207 Init 193
    public byte[] lnxdec(byte abyte0[])
        throws SQLException
    {
        int l = abyte0.length;
        byte abyte1[] = new byte[22];
        System.arraycopy(abyte0, 0, abyte1, 0, l);
        if(NUMBER._isPositive(abyte1))
        {
            int i = (byte)((abyte1[0] & 0xffffff7f) - 65);
            if(i >= 0 && i <= 18)
            {
                int j = i + 1;
                int k = l - 1;
                if(j <= k)
                {
                    abyte1[j]--;
                    if(abyte1[j] == 1 && j == k && --l == 1)
                    {
                        return NUMBER._makeZero();
                    }
                } else
                {
                    abyte1[k]--;
                    for(; j > k; j--)
                    {
                        abyte1[j] = 100;
                    }

                    if(abyte1[1] == 1)
                    {
                        for(int i1 = 1; i1 <= i; i1++)
                        {
                            abyte1[i1] = abyte1[i1 + 1];
                        }

                        i--;
                    }
                    l = i + 2;
                }
                abyte1[0] = (byte)(i + 128 + 64 + 1);
                byte abyte2[] = new byte[l];
                System.arraycopy(abyte1, 0, abyte2, 0, l);
                return abyte2;
            }
        }
        return NUMBER._makeZero();
    }

    // Decompiling method: lnxdiv  Signature: ([B[B)[B
    // Max stack: 7, #locals: 40, #params: 3
    // Code length: 1709 bytes, Code offset: 50432
    // Line Number Table found: 222 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1709 Range 0 1708 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 1709 Range 0 1708 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 1709 Range 0 1708 Init 0
    // RetValue  40 added: Name <returnValue> Type [B At 0 1709 Range 0 1708 Init 0 fixed
    // LocalVar   3 added: Name abyte2 Type [B At 1 489 Range 1 489 Init 1
    // LocalVar   4 added: Name i Type I At 4 439 Range 4 442 Init 4
    // LocalVar   5 added: Name abyte3 Type [B At 7 649 Range 7 655 Init 7
    // LocalVar   6 added: Name j Type I At 12 671 Range 12 682 Init 12
    // LocalVar   7 added: Name abyte4 Type [B At 18 4 Range 18 21 Init 18
    // LocalVar   8 added: Name k Type I At 23 2 Range 23 24 Init 23
    // LocalVar  13 added: Name ai Type [I At 29 1038 Range 29 1066 Init 29
    // LocalVar  18 added: Name ai1 Type [I At 35 829 Range 35 863 Init 35
    // LocalVar  23 added: Name abyte5 Type [B At 41 2 Range 41 42 Init 41
    // LocalVar  26 added: Name ai2 Type [I At 47 1504 Range 47 1550 Init 47
    // LocalVar  11 added: Name flag Type Z At 63 1504 Range 63 1566 Init 63
    // LocalVar  12 added: Name byte0 Type B At 68 1299 Range 68 1366 Init 68
    // LocalVar  16 added: Name flag1 Type Z At 111 1458 Range 111 1568 Init 111
    // LocalVar  17 added: Name byte1 Type B At 117 1256 Range 117 1372 Init 117
    // LocalVar  32 added: Name flag2 Type Z At 208 29 Range 208 236 Init 208
    // LocalVar  32 chged: Name l Oname flag2 Type I At 235 2 Range 208 236 Init 208
    // LocalVar  32 added: Name flag2 Type Z At 277 30 Range 277 306 Init 277
    // LocalVar  32 chged: Name i1 Oname flag2 Type I At 305 2 Range 277 306 Init 277
    // LocalVar  14 added: Name j1 Type I At 336 685 Range 336 1020 Init 336
    // LocalVar  15 added: Name byte2 Type B At 340 164 Range 340 503 Init 340
    // LocalVar   9 added: Name k1 Type I At 346 160 Range 346 505 Init 346
    // LocalVar  15 chged: Name l1 Oname byte2 Type I At 399 3 Range 340 503 Init 340
    // LocalVar  19 added: Name i2 Type I At 515 274 Range 515 788 Init 515
    // LocalVar  20 added: Name j2 Type I At 519 151 Range 519 669 Init 519
    // LocalVar  10 added: Name k2 Type I At 525 147 Range 525 671 Init 525
    // LocalVar  27 added: Name flag2 Type Z At 676 679 Range 676 1354 Init 676
    // LocalVar  28 added: Name byte2 Type B At 679 771 Range 679 1449 Init 679
    // LocalVar  15 added: Name flag3 Type Z At 688 65 Range 688 752 Init 688
    // LocalVar  33 added: Name l2 Type I At 694 20 Range 694 713 Init 694
    // LocalVar  34 added: Name i3 Type I At 700 18 Range 700 717 Init 700
    // LocalVar  35 added: Name j3 Type I At 707 38 Range 707 744 Init 707
    // LocalVar  15 chged: Name k3 Oname flag3 Type I At 709 3 Range 688 752 Init 688
    // LocalVar  33 added: Name l3 Type I At 720 4 Range 720 723 Init 720
    // LocalVar  33 name l3(I) merged out into l2(I)
    // LocalVar  28 chged: Name l3 Oname byte2 Type I At 736 3 Range 679 1449 Init 679
    // LocalVar  38 added: Name flag3 Type Z At 785 301 Range 785 1085 Init 785
    // LocalVar  39 added: Name i4 Type I At 789 300 Range 789 1088 Init 789
    // LocalVar  38 chged: Name j4 Oname flag3 Type I At 793 2 Range 785 1085 Init 785
    // LocalVar  33 added: Name d Type D At 810 75 Range 810 884 Init 810
    // LocalVar  35 added: Name d1 Type D At 827 63 Range 827 889 Init 827
    // LocalVar  37 added: Name k4 Type I At 835 181 Range 835 1015 Init 835
    // LocalVar  15 added: Name l4 Type I At 846 32 Range 846 877 Init 846
    // LocalVar  20 added: Name byte2 Type B At 849 27 Range 849 875 Init 849
    // LocalVar  33 added: Name d2 Type D At 892 4 Range 892 895 Init 892
    // LocalVar  33 name d2(D) merged out into d(D)
    // LocalVar  29 added: Name i5 Type I At 921 29 Range 921 949 Init 921
    // LocalVar  29 added: Name j5 Type I At 968 28 Range 968 995 Init 968
    // LocalVar  15 added: Name k5 Type I At 1050 25 Range 1050 1074 Init 1050
    // LocalVar  27 chged: Name l5 Oname flag2 Type I At 1116 3 Range 676 1354 Init 676
    // LocalVar  30 added: Name flag2 Type Z At 1148 394 Range 1148 1541 Init 1148
    // LocalVar  31 added: Name flag3 Type Z At 1166 288 Range 1166 1453 Init 1166
    // LocalVar  30 chged: Name i6 Oname flag2 Type I At 1175 2 Range 1148 1541 Init 1148
    // LocalVar  31 chged: Name j6 Oname flag3 Type I At 1178 2 Range 1166 1453 Init 1166
    // LocalVar  24 added: Name k6 Type I At 1181 265 Range 1181 1445 Init 1181
    // LocalVar  21 added: Name l6 Type I At 1395 211 Range 1395 1605 Init 1395
    // LocalVar  22 added: Name i7 Type I At 1436 241 Range 1436 1676 Init 1436
    // LocalVar   7 added: Name abyte6 Type [B At 1442 266 Range 1442 1707 Init 1442
    // LocalVar  25 added: Name j7 Type I At 1446 103 Range 1446 1548 Init 1446
    // LocalVar  29 added: Name k7 Type I At 1450 103 Range 1450 1552 Init 1450
    // LocalVar  34 added: Name abyte7 Type [B At 1586 119 Range 1586 1704 Init 1586
    // LocalVar  33 added: Name flag2 Type Z At 1611 86 Range 1611 1696 Init 1611
    // LocalVar  33 chged: Name l7 Oname flag2 Type I At 1637 2 Range 1611 1696 Init 1611
    // LocalVar  20 chged: Name i8 Oname byte2 Type I At 873 3 Range 849 875 Init 849
    // LocalVar  33 added: Name j8 Type I At 1490 34 Range 1490 1523 Init 1490
    // LocalVar  34 added: Name k8 Type I At 1503 8 Range 1503 1510 Init 1503
    // LocalVar   7 name abyte6([B) merged out into abyte4([B)
    // LocalVar  32 name i1(I) merged out into l(I)
    public byte[] lnxdiv(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        byte abyte2[] = abyte0;
        int i = abyte2.length;
        byte abyte3[] = abyte1;
        int j = abyte3.length;
        byte abyte4[] = new byte[22];
        int k = abyte4.length;
        int ai[] = new int[22];
        int ai1[] = new int[10];
        byte abyte5[] = new byte[41];
        int ai2[] = new int[13];
        boolean flag = abyte2[0] >> 7 != 0;
        byte byte0 = abyte2[0];
        if(!flag)
        {
            byte0 = (byte)(~byte0);
            if(abyte2[i - 1] == 102)
            {
                i--;
            }
        }
        boolean flag1 = abyte3[0] >> 7 != 0;
        byte byte1 = abyte3[0];
        if(!flag1)
        {
            byte1 = (byte)(~byte1);
            if(abyte3[j - 1] == 102)
            {
                j--;
            }
        }
        if((byte1 & 0xff) == 128 && j == 1)
        {
            if(flag == flag1)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if((byte0 & 0xff) == 128 && i == 1)
        {
            return NUMBER._makeZero();
        }
        int i6;
        if(i == 1)
        {
            i6 = 0;
        } else
        {
            i6 = 1;
        }
        if((byte0 & 0xff) == 255 && (i == 2 || abyte2[i6] == 101) || i == 1 && abyte2[0] == 0)
        {
            if(flag == flag1)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if(j == 1)
        {
            i6 = 0;
        } else
        {
            i6 = 1;
        }
        if((byte1 & 0xff) == 255 && (j == 2 || abyte3[i6] == 101) || j == 1 && abyte3[0] == 0)
        {
            return NUMBER._makeZero();
        }
        int j1 = i / 2 - 1;
        int k1 = 21;
        int l = i - 2;
        for(; k1 > j1; k1--)
        {
            ai[k1] = 0;
        }

        if(flag)
        {
            if((i & 0x1) == 0)
            {
                ai[k1] = abyte2[l + 1] * 100 - 100;
                l--;
                k1--;
            }
            while(l > 0) 
            {
                ai[k1] = (abyte2[l] * 100 + abyte2[l + 1]) - 101;
                l -= 2;
                k1--;
            }
        } else
        {
            if((i & 0x1) == 0)
            {
                ai[k1] = 10100 - abyte2[l + 1] * 100;
                l--;
                k1--;
            }
            while(l > 0) 
            {
                ai[k1] = 10201 - (abyte2[l] * 100 + abyte2[l + 1]);
                l -= 2;
                k1--;
            }
        }
        int k2 = j / 2 - 1;
        int l2 = k2;
        int i1 = j - 2;
        if(flag1)
        {
            if((j & 0x1) == 0)
            {
                ai1[l2] = abyte3[i1 + 1] * 100 - 100;
                i1--;
                l2--;
            }
            while(i1 > 0) 
            {
                ai1[l2] = (abyte3[i1] * 100 + abyte3[i1 + 1]) - 101;
                i1 -= 2;
                l2--;
            }
        } else
        {
            if((j & 0x1) == 0)
            {
                ai1[l2] = 10100 - abyte3[i1 + 1] * 100;
                i1--;
                l2--;
            }
            while(i1 > 0) 
            {
                ai1[l2] = 10201 - (abyte3[i1] * 100 + abyte3[i1 + 1]);
                i1 -= 2;
                l2--;
            }
        }
        int j4 = 0;
        int k4 = -1;
        if(j <= 3)
        {
            int l1 = 0;
            int j6 = ai[0];
            int i7 = ai1[0];
            do
            {
                int k7 = j6 / i7;
                l1++;
                j6 -= k7 * i7;
                j6 = j6 * 10000 + ai[l1];
                k4++;
                ai2[k4] = k7;
            } while((j6 != 0 || l1 < j1) && k4 < 10 + (ai2[0] != 0 ? 1 : 2));
        } else
        {
            int i8 = 0;
            int j8 = k2;
            double d = (double)(ai[i8] * 10000) + (double)ai[i8 + 1];
            double d1 = (double)(ai1[0] * 10000) + (double)ai1[1];
            do
            {
                int l7 = (int)(d / d1);
                if(l7 != 0)
                {
                    int i2 = i8 + 2;
                    for(int i3 = 2; i2 <= j8; i3++)
                    {
                        ai[i2] -= l7 * ai1[i3];
                        i2++;
                    }

                }
                d -= (double)l7 * d1;
                d = d * 10000D + (double)ai[i8 + 2];
                if(l7 >= 10000)
                {
                    int l4;
                    for(l4 = k4; ai2[l4] == 9999; l4--)
                    {
                        ai2[l4] = 0;
                    }

                    ai2[l4]++;
                    l7 -= 10000;
                }
                if(l7 < 0)
                {
                    int i5;
                    for(i5 = k4; ai2[i5] == 0; i5--)
                    {
                        ai2[i5] = 9999;
                    }

                    ai2[i5]--;
                    l7 += 10000;
                }
                k4++;
                ai2[k4] = l7;
                if(i8 >= j1 && (d >= 0.0D ? d : -d) < 0.10000000000000001D)
                {
                    int j2;
                    for(j2 = i8 + 2; j2 <= j8 && ai[j2] == 0; j2++) { }
                    if(j2 > j8)
                    {
                        break;
                    }
                }
                i8++;
                j8++;
            } while(k4 < 10 + (ai2[0] != 0 ? 1 : 2));
        }
        if(ai2[0] == 0)
        {
            j4++;
        }
        for(; ai2[k4] == 0; k4--) { }
        int k5 = ai2[j4] < 100 ? 0 : 1;
        int l5 = ai2[k4] % 100 == 0 ? 0 : 1;
        int l3 = 2 * (k4 - j4) + k5 + l5;
        if(l3 > 20)
        {
            if(k5 > 0)
            {
                k4 = j4 + 9;
                ai2[k4] += ai2[k4 + 1] < 5000 ? 0 : 1;
            } else
            {
                k4 = j4 + 10;
                ai2[k4] = ((ai2[k4] + 50) / 100) * 100;
            }
            if(ai2[k4] == 10000)
            {
                do
                {
                    k4--;
                } while(ai2[k4] == 9999);
                ai2[k4]++;
            }
            if(ai2[0] != 0)
            {
                j4 = 0;
            }
            for(; ai2[k4] == 0; k4--) { }
            k5 = ai2[j4] < 100 ? 0 : 1;
            l5 = ai2[k4] % 100 == 0 ? 0 : 1;
            l3 = 2 * (k4 - j4) + k5 + l5;
        }
        int j3 = ((byte0 & 0xff) - (byte1 & 0xff) - (ai2[0] != 0 ? 0 : 1)) + 193;
        if(j3 > 255)
        {
            if(flag == flag1)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if(j3 < 128)
        {
            return NUMBER._makeZero();
        }
        int k3 = l3 + 1;
        abyte4 = new byte[k3];
        int i4 = l3;
        int j5 = k4;
        if(l5 == 0)
        {
            abyte4[i4] = (byte)(ai2[j5] / 100 + 1);
            i4--;
            j5--;
        }
        while(i4 > 1) 
        {
            int k6 = ai2[j5] / 100;
            int j7 = ai2[j5] - k6 * 100;
            abyte4[i4] = (byte)(j7 + 1);
            i4--;
            abyte4[i4] = (byte)(k6 + 1);
            i4--;
            j5--;
        }
        if(k5 == 0)
        {
            abyte4[i4] = (byte)(ai2[j5] + 1);
        }
        abyte4[0] = (byte)j3;
        if(flag != flag1)
        {
            byte abyte6[];
            if(++k3 > 20)
            {
                abyte6 = new byte[21];
                k3 = 21;
            } else
            {
                abyte6 = new byte[k3];
            }
            abyte6[0] = (byte)(~j3);
            int l6;
            for(l6 = 0; l6 < k3 - 2; l6++)
            {
                abyte6[l6 + 1] = (byte)(102 - abyte4[l6 + 1]);
            }

            if(k3 <= 20)
            {
                abyte6[k3 - 1] = 102;
            } else
            if(abyte4.length == 20)
            {
                abyte6[k3 - 1] = 102;
            } else
            {
                abyte6[l6 + 1] = (byte)(102 - abyte4[l6 + 1]);
            }
            return abyte6;
        } else
        {
            return abyte4;
        }
    }

    // Decompiling method: lnxexp  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 8 bytes, Code offset: 53073
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 8 Range 0 7 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 8 Range 0 7 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 8 Range 0 7 Init 0 fixed
    public byte[] lnxexp(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 9);
    }

    // Decompiling method: lnxfcn  Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)[B
    // Max stack: 7, #locals: 40, #params: 4
    // Code length: 1635 bytes, Code offset: 53129
    // Line Number Table found: 313 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1635 Range 0 1634 Init 0 fixed
    // Parameter  1 added: Name s Type Ljava/lang/String; At 0 1635 Range 0 1634 Init 0
    // Parameter  2 added: Name s1 Type Ljava/lang/String; At 0 1635 Range 0 1634 Init 0
    // Parameter  3 added: Name s2 Type Ljava/lang/String; At 0 1635 Range 0 1634 Init 0
    // RetValue  40 added: Name <returnValue> Type [B At 0 1635 Range 0 1634 Init 0 fixed
    // LocalVar   4 added: Name byte0 Type B At 2 2 Range 2 3 Init 2
    // LocalVar   5 added: Name byte1 Type B At 6 2 Range 6 7 Init 6
    // LocalVar   6 added: Name byte2 Type B At 10 2 Range 10 11 Init 10
    // LocalVar   7 added: Name byte3 Type B At 14 2 Range 14 15 Init 14
    // LocalVar   8 added: Name byte4 Type B At 18 2 Range 18 19 Init 18
    // LocalVar   9 added: Name byte5 Type B At 22 2 Range 22 23 Init 22
    // LocalVar  10 added: Name byte6 Type B At 26 2 Range 26 27 Init 26
    // LocalVar  11 added: Name byte7 Type B At 30 2 Range 30 31 Init 30
    // LocalVar  12 added: Name byte8 Type B At 34 2 Range 34 35 Init 34
    // LocalVar  13 added: Name byte9 Type B At 38 2 Range 38 39 Init 38
    // LocalVar  14 added: Name byte10 Type B At 42 2 Range 42 43 Init 42
    // LocalVar  15 added: Name byte11 Type B At 46 2 Range 46 47 Init 46
    // LocalVar  16 added: Name byte12 Type B At 50 2 Range 50 51 Init 50
    // LocalVar  17 added: Name byte13 Type B At 54 2 Range 54 55 Init 54
    // LocalVar  18 added: Name byte14 Type B At 58 2 Range 58 59 Init 58
    // LocalVar  19 added: Name byte15 Type B At 62 2 Range 62 63 Init 62
    // LocalVar  20 added: Name byte16 Type B At 66 2 Range 66 67 Init 66
    // LocalVar  21 added: Name c Type C At 71 2 Range 71 72 Init 71
    // LocalVar  22 added: Name lnxlibthinformat Type Loracle/sql/LnxLibThinFormat; At 106 1497 Range 106 1602 Init 106
    // LocalVar  23 added: Name i Type I At 125 1376 Range 125 1500 Init 125
    // LocalVar  24 added: Name j Type I At 132 1427 Range 132 1558 Init 132
    // LocalVar  25 added: Name k Type I At 139 138 Range 139 276 Init 139
    // LocalVar  26 added: Name l Type I At 146 1375 Range 146 1520 Init 146
    // LocalVar  27 added: Name ac Type [C At 223 1209 Range 223 1431 Init 223
    // LocalVar  28 added: Name flag Type Z At 226 1228 Range 226 1453 Init 226
    // LocalVar  29 added: Name i1 Type I At 233 1223 Range 233 1455 Init 233
    // LocalVar  30 added: Name flag1 Type Z At 236 46 Range 236 281 Init 236
    // LocalVar  28 chged: Name j1 Oname flag Type I At 247 2 Range 226 1453 Init 226
    // LocalVar  30 chged: Name k1 Oname flag1 Type I At 273 2 Range 236 281 Init 236
    // LocalVar  31 added: Name ac1 Type [C At 317 1306 Range 317 1622 Init 317
    // LocalVar  32 added: Name flag Type Z At 320 1281 Range 320 1600 Init 320
    // LocalVar  32 chged: Name l1 Oname flag Type I At 367 3 Range 320 1600 Init 320
    // LocalVar  33 added: Name abyte0 Type [B At 623 540 Range 623 1162 Init 623
    // LocalVar  34 added: Name flag Type Z At 626 128 Range 626 753 Init 626
    // LocalVar  35 added: Name flag1 Type Z At 629 571 Range 629 1199 Init 629
    // LocalVar  36 added: Name flag2 Type Z At 632 920 Range 632 1551 Init 632
    // LocalVar  37 added: Name flag3 Type Z At 635 912 Range 635 1546 Init 635
    // LocalVar  36 chged: Name i2 Oname flag2 Type I At 1129 2 Range 632 1551 Init 632
    // LocalVar  38 added: Name j2 Type I At 1132 38 Range 1132 1169 Init 1132
    // LocalVar  34 added: Name flag2 Type Z At 1135 55 Range 1135 1189 Init 1135
    // LocalVar  35 chged: Name k2 Oname flag1 Type I At 1198 2 Range 629 1199 Init 629
    // LocalVar  34 chged: Name l2 Oname flag Type I At 751 3 Range 626 753 Init 626
    // LocalVar  38 added: Name i3 Type I At 1035 41 Range 1035 1075 Init 1035
    // LocalVar  39 added: Name byte17 Type B At 1152 16 Range 1152 1167 Init 1152
    // LocalVar  34 chged: Name j3 Oname flag2 Type I At 1163 2 Range 1135 1189 Init 1135
    // LocalVar  38 added: Name byte18 Type B At 823 16 Range 823 838 Init 823
    public byte[] lnxfcn(String s, String s1, String s2)
        throws SQLException
    {
        byte byte0 = 45;
        byte byte1 = 43;
        byte byte2 = 46;
        byte byte3 = 44;
        byte byte4 = 36;
        byte byte5 = 60;
        byte byte6 = 62;
        byte byte7 = 40;
        byte byte8 = 41;
        byte byte9 = 65;
        byte byte10 = 97;
        byte byte11 = 69;
        byte byte12 = 101;
        byte byte13 = 70;
        byte byte14 = 102;
        byte byte15 = 48;
        byte byte16 = 53;
        char c = '\377';
        if(s2 != null && !s2.equals("AMERICAN_AMERICAN"))
        {
            throw new SQLException(CoreException.getMessage((byte)12));
        }
        LnxLibThinFormat lnxlibthinformat = new LnxLibThinFormat();
        lnxlibthinformat.parseFormat(s1);
        lnxlibthinformat.LNXNFRDX = true;
        int i = lnxlibthinformat.lnxnflhd;
        int j = lnxlibthinformat.lnxnfrhd;
        int k = lnxlibthinformat.lnxnfsiz;
        int l = lnxlibthinformat.lnxnfzld;
        if(lnxlibthinformat.LNXNFFDA | lnxlibthinformat.LNXNFFED | lnxlibthinformat.LNXNFFRN | lnxlibthinformat.LNXNFFTM)
        {
            throw new SQLException(CoreException.getMessage((byte)5));
        }
        if(lnxlibthinformat.LNXNFFRC | lnxlibthinformat.LNXNFFCH | lnxlibthinformat.LNXNFFCT)
        {
            throw new SQLException(CoreException.getMessage((byte)12));
        }
        char ac[] = s.toCharArray();
        int i1 = 0;
        int j1 = ac.length - 1;
        int k1;
        for(k1 = 0; i1 <= j1 && Character.isSpaceChar(ac[i1]); k1++)
        {
            i1++;
        }

        if(lnxlibthinformat.LNXNFFBL && k1 == k && k1 == ac.length)
        {
            return NUMBER._makeZero();
        }
        if(i1 > j1)
        {
            throw new SQLException(CoreException.getMessage((byte)14));
        }
        char ac1[] = new char[255];
        int l1 = 0;
        if(lnxlibthinformat.LNXNFFSH)
        {
            if(ac[i1] != '-' && ac[i1] != '+')
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            ac1[l1++] = ac[i1++];
        } else
        if(lnxlibthinformat.LNXNFFPR)
        {
            if(ac[i1] == '<')
            {
                ac1[l1++] = '-';
                i1++;
            } else
            {
                ac1[l1++] = '+';
            }
        } else
        if(lnxlibthinformat.LNXNFFPT)
        {
            if(ac[i1] == '(')
            {
                ac1[l1++] = '-';
                i1++;
            } else
            {
                ac1[l1++] = '+';
            }
        } else
        if(!lnxlibthinformat.LNXNFFMI && !lnxlibthinformat.LNXNFFST)
        {
            if(ac[i1] == '-')
            {
                ac1[l1++] = ac[i1++];
            }
        } else
        {
            l1++;
        }
        if(i1 > j1)
        {
            throw new SQLException(CoreException.getMessage((byte)14));
        }
        if(lnxlibthinformat.LNXNFFDS)
        {
            if(ac[i1] != '$')
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            if(++i1 > j1)
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
        } else
        if(lnxlibthinformat.LNXNFFCH)
        {
            throw new SQLException(CoreException.getMessage((byte)12));
        }
        byte abyte0[] = new byte[40];
        int i2 = 0;
        int k2 = 0;
        int l2 = 0;
        boolean flag = false;
        while(i1 <= j1) 
        {
            if(Character.isDigit(ac[i1]) || lnxlibthinformat.LNXNFFHX && (ac[i1] >= 'a' && ac[i1] <= 'f' || ac[i1] >= 'A' && ac[i1] <= 'F'))
            {
                ac1[l1++] = ac[i1++];
                l2++;
                continue;
            }
            if(!flag)
            {
                if(lnxlibthinformat.LNXNFRDX)
                {
                    if(ac[i1] == ',')
                    {
                        i1++;
                        abyte0[i2++] = (byte)l2;
                        continue;
                    }
                    if(ac[i1] == '.')
                    {
                        if(l2 > i || l2 < l)
                        {
                            throw new SQLException(CoreException.getMessage((byte)14));
                        }
                        l2 = i - l2;
                        i2 = 0;
                        for(; lnxlibthinformat.lnxnfgps[k2] != 0; k2++)
                        {
                            byte byte17 = (byte)(lnxlibthinformat.lnxnfgps[k2] & 0x7f);
                            if(byte17 > l2)
                            {
                                if(abyte0[i2] != byte17 - l2)
                                {
                                    throw new SQLException(CoreException.getMessage((byte)14));
                                }
                                i2++;
                            }
                        }

                        l2 = 0;
                        flag = true;
                        ac1[l1] = '.';
                        l1++;
                        i1++;
                        continue;
                    }
                } else
                {
                    throw new SQLException(CoreException.getMessage((byte)12));
                }
            }
            if((ac[i1] == 'E' || ac[i1] == 'e') && lnxlibthinformat.LNXNFFSN)
            {
                if(l2 <= 0 && !flag)
                {
                    throw new SQLException(CoreException.getMessage((byte)14));
                }
                ac1[l1++] = ac[i1++];
                if(i1 > j1)
                {
                    throw new SQLException(CoreException.getMessage((byte)14));
                }
                if(ac[i1] == '+' || ac[i1] == '-')
                {
                    ac1[l1++] = ac[i1++];
                }
                int i3 = i1;
                for(; i1 <= j1 && Character.isDigit(ac[i1]); ac1[l1++] = ac[i1++]) { }
                if(i3 == i1)
                {
                    throw new SQLException(CoreException.getMessage((byte)14));
                }
                continue;
            }
            if(lnxlibthinformat.LNXNFFRC)
            {
                throw new SQLException(CoreException.getMessage((byte)12));
            }
            break;
        }
        if(!flag)
        {
            int j3 = i - l2;
            int j2 = 0;
            for(; lnxlibthinformat.lnxnfgps[k2] != 0; k2++)
            {
                byte byte18 = (byte)(lnxlibthinformat.lnxnfgps[k2] & 0x7f);
                if(byte18 > j3)
                {
                    if(abyte0[j2] != byte18 - j3)
                    {
                        throw new SQLException(CoreException.getMessage((byte)14));
                    }
                    j2++;
                }
            }

        }
        if(lnxlibthinformat.LNXNFFCT)
        {
            throw new SQLException(CoreException.getMessage((byte)12));
        }
        if(lnxlibthinformat.LNXNFFST)
        {
            if(i1 > j1)
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            if(ac[i1] != '-' && ac[i1] != '+')
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            ac1[0] = ac[i1];
            i1++;
        } else
        if(lnxlibthinformat.LNXNFFMI)
        {
            if(i1 > j1)
            {
                if(lnxlibthinformat.LNXNFFIL || i1 != ac.length)
                {
                    throw new SQLException(CoreException.getMessage((byte)14));
                }
                ac1[0] = '+';
            } else
            {
                ac1[0] = ac[i1] != '-' ? '+' : '-';
                i1++;
            }
        } else
        if(lnxlibthinformat.LNXNFFPR)
        {
            if(ac[i1] == '>' && ac1[0] == '-')
            {
                i1++;
            }
        } else
        if(lnxlibthinformat.LNXNFFPT && i1 < ac.length && ac[i1] == ')' && ac1[0] == '-')
        {
            i1++;
        }
        if(i1 <= j1)
        {
            throw new SQLException(CoreException.getMessage((byte)14));
        }
        if(flag)
        {
            if(l2 > j)
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
        } else
        {
            if(l2 > i)
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            if(l2 < l)
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
        }
        if(lnxlibthinformat.LNXNFF05 && (flag && l2 == j || j == 0))
        {
            l1--;
            if(ac1[l1] != '0' && ac1[l1] != '5')
            {
                throw new SQLException(CoreException.getMessage((byte)14));
            }
            l1++;
        }
        if(lnxlibthinformat.LNXNFFHX)
        {
            return lnxqh2n(ac1);
        } else
        {
            return lnxcpn(new String(ac1), false, 0, false, 0, s2);
        }
    }

    // Decompiling method: lnxflo  Signature: ([B)[B
    // Max stack: 3, #locals: 3, #params: 2
    // Code length: 33 bytes, Code offset: 56060
    // Line Number Table found: 4 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 33 Range 0 32 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 33 Range 0 32 Init 0
    // RetValue   3 added: Name <returnValue> Type [B At 0 33 Range 0 32 Init 0 fixed
    // LocalVar   2 added: Name abyte1 Type [B At 6 26 Range 6 31 Init 6
    public byte[] lnxflo(byte abyte0[])
        throws SQLException
    {
        byte abyte1[] = lnxtru(abyte0, 0);
        if(Datum.compareBytes(abyte1, abyte0) != 0 && !NUMBER._isPositive(abyte0))
        {
            abyte1 = lnxsub(abyte1, lnxqone);
        }
        return abyte1;
    }

    // Decompiling method: lnxfpr  Signature: ([BI)[B
    // Max stack: 5, #locals: 14, #params: 3
    // Code length: 652 bytes, Code offset: 56153
    // Line Number Table found: 73 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 652 Range 0 651 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 652 Range 0 651 Init 0
    // Parameter  2 added: Name i Type I At 0 652 Range 0 651 Init 0
    // RetValue  14 added: Name <returnValue> Type [B At 0 652 Range 0 651 Init 0 fixed
    // LocalVar  12 added: Name j Type I At 2 231 Range 2 232 Init 2
    // LocalVar   6 added: Name flag Type Z At 50 488 Range 50 537 Init 50
    // LocalVar   7 added: Name k Type I At 78 563 Range 78 640 Init 78
    // LocalVar   8 added: Name flag1 Type Z At 92 294 Range 92 385 Init 92
    // LocalVar   9 added: Name flag2 Type Z At 95 532 Range 95 626 Init 95
    // LocalVar  10 added: Name byte0 Type B At 99 422 Range 99 520 Init 99
    // LocalVar  11 added: Name flag3 Type Z At 102 481 Range 102 582 Init 102
    // LocalVar   9 chged: Name byte1 Oname flag2 Type B At 148 479 Range 95 626 Init 95
    // LocalVar  11 chged: Name byte2 Oname flag3 Type B At 154 429 Range 102 582 Init 102
    // LocalVar   3 added: Name abyte1 Type [B At 185 461 Range 185 645 Init 185
    // LocalVar   5 added: Name byte3 Type B At 380 103 Range 380 482 Init 380
    // LocalVar   4 added: Name byte4 Type B At 382 223 Range 382 604 Init 382
    // LocalVar   5 added: Name byte5 Type B At 486 146 Range 486 631 Init 486
    // LocalVar  13 added: Name l Type I At 590 58 Range 590 647 Init 590
    // LocalVar   5 name byte5(B) merged out into byte3(B)
    public byte[] lnxfpr(byte abyte0[], int i)
        throws SQLException
    {
        int k = abyte0.length;
        if(NUMBER._isZero(abyte0))
        {
            return NUMBER._makeZero();
        }
        if(NUMBER._isNegInf(abyte0))
        {
            return NUMBER._makeNegInf();
        }
        if(NUMBER._isPosInf(abyte0))
        {
            return NUMBER._makePosInf();
        }
        if(i < 0)
        {
            return NUMBER._makeZero();
        }
        boolean flag;
        int j;
        boolean flag1;
        byte byte2;
        byte byte3;
        byte byte4;
        if(flag = NUMBER._isPositive(abyte0))
        {
            i += (abyte0[1] & 0xff) >= 11 ? 1 : 2;
            j = i >> 1;
            flag1 = (i & 0x1) == 1;
            byte2 = 1;
            byte3 = 100;
            byte4 = 1;
        } else
        {
            i += (abyte0[1] & 0xff) <= 91 ? 1 : 2;
            j = i >> 1;
            flag1 = (i & 0x1) == 1;
            byte2 = 101;
            byte3 = 2;
            byte4 = -1;
            k -= (abyte0[k - 1] & 0xff) != 102 ? 0 : 1;
        }
        byte abyte1[] = new byte[k];
        System.arraycopy(abyte0, 0, abyte1, 0, k);
        if(j > k - 1 || j == k - 1 && (flag1 || LnxqFirstDigit[abyte0[j]] == 1))
        {
            return _setLength(abyte0, k);
        }
        if(j == 0 && (!flag1 || (flag ? abyte0[1] < 51 || false : abyte0[1] > 51 || false)) || j == 1 && !flag1 && (flag ? abyte0[1] < 6 || false : abyte0[1] > 96 || false))
        {
            return NUMBER._makeZero();
        }
        if(j == 0)
        {
            if(NUMBER._isInf(abyte0))
            {
                if(flag)
                {
                    return NUMBER._makePosInf();
                } else
                {
                    return NUMBER._makeNegInf();
                }
            } else
            {
                abyte1[0] = (byte)(abyte0[0] + byte4);
                abyte1[1] = (byte)(byte2 + byte4);
                return _setLength(abyte1, 2);
            }
        }
        byte byte1;
        byte byte0 = byte1 = (byte)j;
        if(flag1)
        {
            if(flag ? abyte0[byte1 + 1] > 50 || false : abyte0[byte1 + 1] < 52 || false)
            {
                abyte1[byte0] = (byte)(abyte0[byte1] + byte4);
            } else
            {
                abyte1[byte0] = abyte0[byte1];
            }
        } else
        {
            abyte1[byte0] = flag ? LnxqRound_P[abyte0[byte1]] : LnxqRound_N[abyte0[byte1]];
        }
        byte1--;
        int l;
        if(abyte1[byte0] == byte3 + byte4)
        {
            for(; byte1 > 0 && abyte0[byte1] == byte3; byte1--) { }
            if(byte1 == 0)
            {
                if(NUMBER._isInf(abyte0))
                {
                    if(flag)
                    {
                        return NUMBER._makePosInf();
                    } else
                    {
                        return NUMBER._makeNegInf();
                    }
                } else
                {
                    abyte1[0] = (byte)(abyte0[0] + byte4);
                    abyte1[1] = (byte)(byte2 + byte4);
                    return _setLength(abyte1, 2);
                }
            }
            abyte1[byte1] = (byte)(abyte0[byte1] + byte4);
            l = byte1 + 1;
            byte1--;
        } else
        if(abyte1[byte0] == byte2)
        {
            for(; abyte0[byte1] == byte2; byte1--) { }
            l = byte1 + 1;
        } else
        {
            l = j + 1;
        }
        return _setLength(abyte1, l);
    }

    // Decompiling method: lnxinc  Signature: ([B)[B
    // Max stack: 5, #locals: 9, #params: 2
    // Code length: 235 bytes, Code offset: 57141
    // Line Number Table found: 38 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 235 Range 0 234 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 235 Range 0 234 Init 0
    // RetValue   9 added: Name <returnValue> Type [B At 0 235 Range 0 234 Init 0 fixed
    // LocalVar   6 added: Name i Type I At 2 227 Range 2 228 Init 2
    // LocalVar   7 added: Name abyte1 Type [B At 8 215 Range 8 222 Init 8
    // LocalVar   2 added: Name flag Type Z At 21 134 Range 21 154 Init 21
    // LocalVar   5 added: Name byte0 Type B At 34 160 Range 34 193 Init 34
    // LocalVar   3 added: Name byte1 Type B At 53 116 Range 53 168 Init 53
    // LocalVar   4 added: Name byte2 Type B At 59 130 Range 59 188 Init 59
    // LocalVar   2 chged: Name j Oname flag Type I At 90 1 Range 21 154 Init 21
    // LocalVar   5 chged: Name k Oname byte0 Type I At 124 3 Range 34 193 Init 34
    // LocalVar   3 added: Name byte0 Type B At 172 15 Range 172 186 Init 172
    // LocalVar   8 added: Name abyte2 Type [B At 219 15 Range 219 233 Init 219
    // LocalVar   3 name byte0(B) merged out into byte1(B)
    public byte[] lnxinc(byte abyte0[])
        throws SQLException
    {
        int k = abyte0.length;
        byte abyte1[] = new byte[22];
        System.arraycopy(abyte0, 0, abyte1, 0, k);
        int i = 0;
        int j = (byte)((abyte1[0] & 0xffffff7f) - 65);
        if(j >= 0 && j <= 18)
        {
            byte byte0 = (byte)(j + 1);
            byte byte1 = (byte)(k - 1);
            if(byte0 <= byte1)
            {
                if(abyte1[byte0] < 100)
                {
                    abyte1[byte0]++;
                } else
                {
                    abyte1[i] = 0;
                    do
                    {
                        byte0--;
                    } while(abyte1[byte0] == 100);
                    if(byte0 > i)
                    {
                        abyte1[byte0]++;
                    } else
                    {
                        j++;
                        byte0++;
                        abyte1[byte0] = 2;
                    }
                    abyte1[i] = (byte)(j + 128 + 64 + 1);
                    k = (byte0 - i) + 1;
                }
            } else
            {
                abyte1[byte0] = 2;
                for(byte0--; byte0 > byte1; byte0--)
                {
                    abyte1[byte0] = 1;
                }

                k = j + 2;
            }
        } else
        {
            abyte1[0] = -63;
            abyte1[1] = 2;
            k = 2;
        }
        byte abyte2[] = new byte[k];
        System.arraycopy(abyte1, 0, abyte2, 0, k);
        return abyte2;
    }

    // Decompiling method: lnxln  Signature: ([B)[B
    // Max stack: 5, #locals: 15, #params: 2
    // Code length: 267 bytes, Code offset: 57572
    // Line Number Table found: 32 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 267 Range 0 266 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 267 Range 0 266 Init 0
    // RetValue  15 added: Name <returnValue> Type [B At 0 267 Range 0 266 Init 0 fixed
    // LocalVar   2 added: Name abyte1 Type [B At 27 58 Range 27 84 Init 27
    // LocalVar   3 added: Name i Type I At 48 171 Range 48 218 Init 48
    // LocalVar   4 added: Name d Type D At 59 4 Range 59 62 Init 59
    // LocalVar   6 added: Name d1 Type D At 66 4 Range 66 69 Init 66
    // LocalVar   8 added: Name abyte2 Type [B At 73 180 Range 73 252 Init 73
    // LocalVar   9 added: Name abyte3 Type [B At 81 6 Range 81 86 Init 81
    // LocalVar  10 added: Name abyte4 Type [B At 90 5 Range 90 94 Init 90
    // LocalVar  10 added: Name abyte5 Type [B At 101 96 Range 101 196 Init 101
    // LocalVar  11 added: Name abyte6 Type [B At 108 155 Range 108 262 Init 108
    // LocalVar  12 added: Name abyte7 Type [B At 130 76 Range 130 205 Init 130
    // LocalVar  13 added: Name flag Type Z At 133 46 Range 133 178 Init 133
    // LocalVar   3 added: Name j Type I At 221 11 Range 221 231 Init 221
    // LocalVar  14 added: Name abyte8 Type [B At 228 15 Range 228 242 Init 228
    // LocalVar  10 added: Name abyte9 Type [B At 236 5 Range 236 240 Init 236
    // LocalVar   9 added: Name abyte10 Type [B At 246 5 Range 246 250 Init 246
    // LocalVar   9 added: Name abyte11 Type [B At 256 5 Range 256 260 Init 256
    // LocalVar  13 chged: Name k Oname flag Type I At 138 3 Range 133 178 Init 133
    // LocalVar   9 added: Name abyte12 Type [B At 149 7 Range 149 155 Init 149
    // LocalVar   9 added: Name abyte13 Type [B At 182 7 Range 182 188 Init 182
    // LocalVar   3 name j(I) merged out into i(I)
    // LocalVar   9 name abyte10([B) merged out into abyte3([B)
    // LocalVar   9 name abyte12([B) merged out into abyte3([B)
    // LocalVar   9 name abyte13([B) merged out into abyte3([B)
    // LocalVar   9 name abyte11([B) merged out into abyte3([B)
    // LocalVar  10 name abyte5([B) merged out into abyte4([B)
    // LocalVar  10 name abyte9([B) merged out into abyte4([B)
    public byte[] lnxln(byte abyte0[])
        throws SQLException
    {
        if(lnxsgn(abyte0) <= 0)
        {
            return NUMBER._makeNegInf();
        }
        if(NUMBER._isPosInf(abyte0))
        {
            return NUMBER._makePosInf();
        }
        byte abyte1[] = new byte[abyte0.length];
        System.arraycopy(abyte0, 0, abyte1, 0, abyte0.length);
        int i = (abyte1[0] & 0xff) - 193;
        abyte1[0] = -63;
        double d = lnxnur(abyte1);
        double d1 = Math.log(d);
        byte abyte2[] = NUMBER.toBytes(d1);
        byte abyte3[] = lnxexp(abyte2);
        byte abyte4[] = lnxdiv(abyte1, abyte3);
        abyte4 = lnxsub(abyte4, lnxqone);
        byte abyte5[] = new byte[abyte4.length];
        System.arraycopy(abyte4, 0, abyte5, 0, abyte4.length);
        byte abyte6[] = lnxmul(abyte4, abyte4);
        int j = 1;
        for(; (abyte6[0] & 0xff) > 172; abyte6 = lnxmul(abyte4, abyte6))
        {
            j++;
            abyte3 = lnxqIDiv(abyte6, j);
            abyte5 = lnxsub(abyte5, abyte3);
            abyte6 = lnxmul(abyte4, abyte6);
            j++;
            abyte3 = lnxqIDiv(abyte6, j);
            abyte5 = lnxadd(abyte5, abyte3);
        }

        i *= 2;
        byte abyte7[] = NUMBER.ln10().shareBytes();
        abyte4 = lnxmin(i);
        abyte3 = lnxmul(abyte4, abyte7);
        abyte3 = lnxadd(abyte3, abyte2);
        return lnxadd(abyte3, abyte5);
    }

    // Decompiling method: lnxlog  Signature: ([B[B)[B
    // Max stack: 4, #locals: 8, #params: 3
    // Code length: 70 bytes, Code offset: 58011
    // Line Number Table found: 10 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 70 Range 0 69 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 70 Range 0 69 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 70 Range 0 69 Init 0
    // RetValue   8 added: Name <returnValue> Type [B At 0 70 Range 0 69 Init 0 fixed
    // LocalVar   3 added: Name d Type D At 4 8 Range 4 11 Init 4
    // LocalVar   5 added: Name abyte2 Type [B At 24 13 Range 24 36 Init 24
    // LocalVar   7 added: Name abyte3 Type [B At 32 7 Range 32 38 Init 32
    // LocalVar   5 added: Name abyte4 Type [B At 48 12 Range 48 59 Init 48
    // LocalVar   6 added: Name abyte5 Type [B At 55 7 Range 55 61 Init 55
    public byte[] lnxlog(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        double d = NUMBER.toDouble(abyte1);
        if(d > 0.0D)
        {
            if(d == 10D)
            {
                byte abyte2[] = lnxln(abyte0);
                byte abyte5[] = NUMBER.ln10().shareBytes();
                return lnxdiv(abyte2, abyte5);
            } else
            {
                byte abyte3[] = lnxln(abyte0);
                byte abyte4[] = lnxln(abyte1);
                return lnxdiv(abyte3, abyte4);
            }
        } else
        {
            return NUMBER._makeNegInf();
        }
    }

    // Decompiling method: lnxmin  Signature: (J)[B
    // Max stack: 6, #locals: 11, #params: 3
    // Code length: 173 bytes, Code offset: 58165
    // Line Number Table found: 22 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 173 Range 0 172 Init 0 fixed
    // Parameter  1 added: Name l Type J At 0 173 Range 0 172 Init 0
    // RetValue  11 added: Name <returnValue> Type [B At 0 173 Range 0 172 Init 0 fixed
    // LocalVar   4 added: Name abyte0 Type [B At 4 90 Range 4 93 Init 4
    // LocalVar   7 added: Name abyte1 Type [B At 10 147 Range 10 156 Init 10
    // LocalVar   8 added: Name flag Type Z At 13 150 Range 13 162 Init 13
    // LocalVar   3 added: Name flag1 Type Z At 36 133 Range 36 168 Init 36
    // LocalVar   5 added: Name flag2 Type Z At 38 100 Range 38 137 Init 38
    // LocalVar   5 chged: Name i Oname flag2 Type I At 73 3 Range 38 137 Init 38
    // LocalVar   6 added: Name byte0 Type B At 79 75 Range 79 153 Init 79
    // LocalVar   9 added: Name byte1 Type B At 83 25 Range 83 107 Init 83
    // LocalVar   8 chged: Name j Oname flag Type I At 108 2 Range 13 162 Init 13
    // LocalVar  10 added: Name abyte2 Type [B At 147 21 Range 147 167 Init 147
    // LocalVar   8 chged: Name byte2 Oname j Type B At 90 73 Range 13 162 Init 13
    // LocalVar   9 chged: Name j Oname byte1 Type I At 105 3 Range 83 107 Init 83
    public byte[] lnxmin(long l)
    {
        byte abyte0[] = new byte[20];
        byte abyte1[] = new byte[20];
        byte byte1 = 0;
        if(l == 0L)
        {
            return NUMBER._makeZero();
        }
        boolean flag = l >= 0L;
        int i;
        for(i = 0; l != 0L; i++)
        {
            abyte0[i] = (byte)(int)Math.abs(l % 100L);
            l /= 100L;
        }

        byte byte0 = (byte)(--i);
        for(int j = byte0; byte1 <= byte0; j--)
        {
            abyte1[byte1] = abyte0[j];
            byte1++;
        }

        while(i > 0) 
        {
            if(abyte1[i--] != 0)
            {
                break;
            }
            byte1--;
        }
        byte abyte2[] = new byte[byte1 + 1];
        abyte2[0] = byte0;
        System.arraycopy(abyte1, 0, abyte2, 1, byte1);
        return NUMBER._toLnxFmt(abyte2, flag);
    }

    // Decompiling method: lnxmod  Signature: ([B[B)[B
    // Max stack: 3, #locals: 6, #params: 3
    // Code length: 34 bytes, Code offset: 58460
    // Line Number Table found: 5 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 34 Range 0 33 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 34 Range 0 33 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 34 Range 0 33 Init 0
    // RetValue   6 added: Name <returnValue> Type [B At 0 34 Range 0 33 Init 0 fixed
    // LocalVar   3 added: Name abyte2 Type [B At 6 3 Range 6 8 Init 6
    // LocalVar   4 added: Name abyte3 Type [B At 13 6 Range 13 18 Init 13
    // LocalVar   3 added: Name abyte4 Type [B At 22 4 Range 22 25 Init 22
    // LocalVar   5 added: Name abyte5 Type [B At 29 4 Range 29 32 Init 29
    // LocalVar   3 name abyte4([B) merged out into abyte2([B)
    public byte[] lnxmod(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        byte abyte2[] = lnxdiv(abyte0, abyte1);
        byte abyte3[] = lnxtru(abyte2, 0);
        abyte2 = lnxmul(abyte1, abyte3);
        byte abyte4[] = lnxsub(abyte0, abyte2);
        return abyte4;
    }

    // Decompiling method: lnxmul  Signature: ([B[B)[B
    // Max stack: 7, #locals: 32, #params: 3
    // Code length: 1941 bytes, Code offset: 58558
    // Line Number Table found: 205 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1941 Range 0 1940 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 1941 Range 0 1940 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 1941 Range 0 1940 Init 0
    // RetValue  32 added: Name <returnValue> Type [B At 0 1941 Range 0 1940 Init 0 fixed
    // LocalVar   3 added: Name abyte2 Type [B At 1 478 Range 1 478 Init 1
    // LocalVar   4 added: Name i Type I At 4 1135 Range 4 1138 Init 4
    // LocalVar   5 added: Name abyte3 Type [B At 7 638 Range 7 644 Init 7
    // LocalVar   6 added: Name j Type I At 12 732 Range 12 743 Init 12
    // LocalVar   7 added: Name abyte4 Type [B At 18 4 Range 18 21 Init 18
    // LocalVar   8 added: Name k Type I At 23 2 Range 23 24 Init 23
    // LocalVar  13 added: Name ai Type [I At 29 1578 Range 29 1606 Init 29
    // LocalVar  18 added: Name ai1 Type [I At 35 1576 Range 35 1610 Init 35
    // LocalVar  21 added: Name flag Type Z At 38 2 Range 38 39 Init 38
    // LocalVar  23 added: Name abyte5 Type [B At 44 1875 Range 44 1918 Init 44
    // LocalVar  24 added: Name flag1 Type Z At 47 2 Range 47 48 Init 47
    // LocalVar  26 added: Name flag2 Type Z At 50 814 Range 50 863 Init 50
    // LocalVar  27 added: Name flag3 Type Z At 53 2 Range 53 54 Init 53
    // LocalVar  11 added: Name flag4 Type Z At 69 1751 Range 69 1819 Init 69
    // LocalVar  12 added: Name byte0 Type B At 74 644 Range 74 717 Init 74
    // LocalVar  16 added: Name flag5 Type Z At 117 1705 Range 117 1821 Init 117
    // LocalVar  17 added: Name byte1 Type B At 123 601 Range 123 723 Init 123
    // LocalVar   7 added: Name abyte6 Type [B At 170 4 Range 170 173 Init 170
    // LocalVar   7 added: Name abyte7 Type [B At 193 4 Range 193 196 Init 193
    // LocalVar   7 added: Name abyte8 Type [B At 234 12 Range 234 245 Init 234
    // LocalVar   7 added: Name abyte9 Type [B At 284 12 Range 284 295 Init 284
    // LocalVar  29 added: Name abyte10 Type [B At 305 7 Range 305 311 Init 305
    // LocalVar  30 added: Name l Type I At 316 8 Range 316 323 Init 316
    // LocalVar  31 added: Name flag6 Type Z At 328 8 Range 328 335 Init 328
    // LocalVar  14 added: Name i1 Type I At 344 1039 Range 344 1382 Init 344
    // LocalVar  15 added: Name j1 Type I At 348 145 Range 348 492 Init 348
    // LocalVar   9 added: Name k1 Type I At 354 141 Range 354 494 Init 354
    // LocalVar  19 added: Name l1 Type I At 504 623 Range 504 1126 Init 504
    // LocalVar  20 added: Name i2 Type I At 508 151 Range 508 658 Init 508
    // LocalVar  10 added: Name j2 Type I At 514 147 Range 514 660 Init 514
    // LocalVar  21 added: Name word0 Type S At 696 1207 Range 696 1902 Init 696
    // LocalVar  22 added: Name k2 Type I At 711 1222 Range 711 1932 Init 711
    // LocalVar  24 added: Name flag7 Type Z At 754 1167 Range 754 1920 Init 754
    // LocalVar  25 added: Name l2 Type I At 758 133 Range 758 890 Init 758
    // LocalVar  26 chged: Name i3 Oname flag2 Type I At 776 8 Range 50 863 Init 50
    // LocalVar  20 added: Name j3 Type I At 799 42 Range 799 840 Init 799
    // LocalVar  26 added: Name k3 Type I At 876 8 Range 876 883 Init 876
    // LocalVar  26 added: Name l3 Type I At 887 464 Range 887 1350 Init 887
    // LocalVar  20 added: Name i4 Type I At 899 479 Range 899 1377 Init 899
    // LocalVar  26 added: Name j4 Type I At 1354 8 Range 1354 1361 Init 1354
    // LocalVar  26 name j4(I) merged out into l3(I)
    // LocalVar  15 added: Name j4 Type I At 1385 215 Range 1385 1599 Init 1385
    // LocalVar  26 added: Name k4 Type I At 1615 8 Range 1615 1622 Init 1615
    // LocalVar  26 added: Name l4 Type I At 1626 14 Range 1626 1639 Init 1626
    // LocalVar  24 chged: Name i5 Oname flag7 Type I At 1675 3 Range 754 1920 Init 754
    // LocalVar  25 added: Name j5 Type I At 1710 41 Range 1710 1750 Init 1710
    // LocalVar   7 added: Name abyte11 Type [B At 1832 108 Range 1832 1939 Init 1832
    // LocalVar  28 added: Name flag2 Type Z At 1844 29 Range 1844 1872 Init 1844
    // LocalVar  28 chged: Name k5 Oname flag2 Type I At 1871 2 Range 1844 1872 Init 1844
    // LocalVar  28 added: Name flag2 Type Z At 1906 25 Range 1906 1930 Init 1906
    // LocalVar  28 chged: Name l5 Oname flag2 Type I At 1929 2 Range 1906 1930 Init 1906
    // LocalVar   7 name abyte11([B) merged out into abyte4([B)
    // LocalVar   7 name abyte6([B) merged out into abyte4([B)
    // LocalVar   7 name abyte7([B) merged out into abyte4([B)
    // LocalVar   7 name abyte8([B) merged out into abyte4([B)
    // LocalVar   7 name abyte9([B) merged out into abyte4([B)
    // LocalVar  21 chged: Name word1 Oname flag Type S At 38 2 Range 38 39 Init 38
    // LocalVar  21 name word0(S) merged out into word1(S)
    // LocalVar  24 chged: Name i6 Oname flag1 Type I At 47 2 Range 47 48 Init 47
    // LocalVar  24 name i5(I) merged out into i6(I)
    // LocalVar  26 name k3(I) merged out into i3(I)
    // LocalVar  26 name l3(I) merged out into i3(I)
    // LocalVar  26 name k4(I) merged out into i3(I)
    // LocalVar  26 name l4(I) merged out into i3(I)
    public byte[] lnxmul(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        byte abyte2[] = abyte0;
        int i = abyte2.length;
        byte abyte3[] = abyte1;
        int j = abyte3.length;
        byte abyte4[] = new byte[22];
        int k = abyte4.length;
        int ai[] = new int[10];
        int ai1[] = new int[10];
        short word0 = 0;
        byte abyte5[] = new byte[41];
        int j3 = 0;
        int i4 = 0;
        boolean flag2 = false;
        boolean flag = abyte2[0] >> 7 != 0;
        byte byte0 = abyte2[0];
        if(!flag)
        {
            byte0 = (byte)(~byte0);
            if(abyte2[i - 1] == 102)
            {
                i--;
            }
        }
        boolean flag1 = abyte3[0] >> 7 != 0;
        byte byte1 = abyte3[0];
        if(!flag1)
        {
            byte1 = (byte)(~byte1);
            if(abyte3[j - 1] == 102)
            {
                j--;
            }
        }
        if(-byte0 == 128 && i == 1)
        {
            abyte4 = NUMBER._makeZero();
            return abyte4;
        }
        if(-byte1 == 128 && j == 1)
        {
            abyte4 = NUMBER._makeZero();
            return abyte4;
        }
        if((byte0 & 0xff) == 255 && (i == 1 || abyte2[1] == 101))
        {
            if(flag == flag1)
            {
                abyte4 = NUMBER._makePosInf();
            } else
            {
                abyte4 = NUMBER._makeNegInf();
            }
            return abyte4;
        }
        if((byte1 & 0xff) == 255 && (j == 1 || abyte3[1] == 101))
        {
            if(flag == flag1)
            {
                abyte4 = NUMBER._makePosInf();
            } else
            {
                abyte4 = NUMBER._makeNegInf();
            }
            return abyte4;
        }
        if(i > j)
        {
            byte abyte6[] = abyte2;
            abyte2 = abyte3;
            abyte3 = abyte6;
            int l4 = i;
            i = j;
            j = l4;
            boolean flag3 = flag;
            flag = flag1;
            flag1 = flag3;
        }
        int j1 = i / 2 - 1;
        int k1 = j1;
        int l = i - 2;
        if(flag)
        {
            if((i & 0x1) == 0)
            {
                ai[k1] = abyte2[l + 1] * 100 - 100;
                l--;
                k1--;
            }
            while(l > 0) 
            {
                ai[k1] = (abyte2[l] * 100 + abyte2[l + 1]) - 101;
                l -= 2;
                k1--;
            }
        } else
        {
            if((i & 0x1) == 0)
            {
                ai[k1] = 10100 - abyte2[l + 1] * 100;
                l--;
                k1--;
            }
            while(l > 0) 
            {
                ai[k1] = 10201 - (abyte2[l] * 100 + abyte2[l + 1]);
                l -= 2;
                k1--;
            }
        }
        int i2 = j / 2 - 1;
        int j2 = i2;
        int i1 = j - 2;
        if(flag1)
        {
            if((j & 0x1) == 0)
            {
                ai1[j2] = abyte3[i1 + 1] * 100 - 100;
                i1--;
                j2--;
            }
            while(i1 > 0) 
            {
                ai1[j2] = (abyte3[i1] * 100 + abyte3[i1 + 1]) - 101;
                i1 -= 2;
                j2--;
            }
        } else
        {
            if((j & 0x1) == 0)
            {
                ai1[j2] = 10100 - abyte3[i1 + 1] * 100;
                i1--;
                j2--;
            }
            while(i1 > 0) 
            {
                ai1[j2] = 10201 - (abyte3[i1] * 100 + abyte3[i1 + 1]);
                i1 -= 2;
                j2--;
            }
        }
        int i3;
        if(ai[0] * ai1[0] < 0xf4240)
        {
            word0 = (short)(((byte0 & 0xff) + (byte1 & 0xff)) - 193);
            i3 = (i & 0xfe) + (j & 0xfe);
        } else
        {
            word0 = (short)(((byte0 & 0xff) + (byte1 & 0xff)) - 192);
            i3 = (i & 0xfe) + (j & 0xfe) + 1;
        }
        j3 = 1;
        int k3 = i3;
        if(i <= 3)
        {
            i4 = ai[0] * ai1[i2];
            i4 = LnxmulSetDigit1(abyte5, k3, i4);
            k3 -= 2;
            for(int k2 = i2 - 1; k2 >= 0; k2--)
            {
                i4 += ai[0] * ai1[k2];
                i4 = LnxmulSetDigit1(abyte5, k3, i4);
                k3 -= 2;
            }

            LnxmulSetDigit2(abyte5, k3, i4);
            k3 -= 2;
        } else
        {
            i4 += ai[j1] * ai1[i2];
            i4 = LnxmulSetDigit1(abyte5, k3, i4);
            k3 -= 2;
            int l2;
            for(l2 = i2 - 1; l2 > i2 - (i / 2 - 1); l2--)
            {
                switch((i2 - l2) + 1)
                {
                case 9: // '\t'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 8, i4);
                    // fall through

                case 8: // '\b'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 7, i4);
                    // fall through

                case 7: // '\007'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 6, i4);
                    // fall through

                case 6: // '\006'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 5, i4);
                    // fall through

                case 5: // '\005'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 4, i4);
                    // fall through

                case 4: // '\004'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 3, i4);
                    // fall through

                case 3: // '\003'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 2, i4);
                    // fall through

                case 2: // '\002'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 1, i4);
                    // fall through

                default:
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 0, i4);
                    break;
                }
                i4 = LnxmulSetDigit1(abyte5, k3, i4);
                k3 -= 2;
            }

            do
            {
                switch(i / 2)
                {
                case 10: // '\n'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 9, i4);
                    // fall through

                case 9: // '\t'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 8, i4);
                    // fall through

                case 8: // '\b'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 7, i4);
                    // fall through

                case 7: // '\007'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 6, i4);
                    // fall through

                case 6: // '\006'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 5, i4);
                    // fall through

                case 5: // '\005'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 4, i4);
                    // fall through

                case 4: // '\004'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 3, i4);
                    // fall through

                case 3: // '\003'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 2, i4);
                    // fall through

                case 2: // '\002'
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 1, i4);
                    // fall through

                default:
                    i4 = LnxmulSetSum(ai, ai1, j1, l2, 0, i4);
                    break;
                }
                i4 = LnxmulSetDigit1(abyte5, k3, i4);
                k3 -= 2;
            } while(--l2 >= 0);
            for(int l1 = j1 - 1; l1 > 0; l1--)
            {
                switch(l1 + 1)
                {
                case 9: // '\t'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 8, i4);
                    // fall through

                case 8: // '\b'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 7, i4);
                    // fall through

                case 7: // '\007'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 6, i4);
                    // fall through

                case 6: // '\006'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 5, i4);
                    // fall through

                case 5: // '\005'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 4, i4);
                    // fall through

                case 4: // '\004'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 3, i4);
                    // fall through

                case 3: // '\003'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 2, i4);
                    // fall through

                case 2: // '\002'
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 1, i4);
                    // fall through

                default:
                    i4 = LnxmulSetSum(ai, ai1, l1, 0, 0, i4);
                    break;
                }
                i4 = LnxmulSetDigit1(abyte5, k3, i4);
                k3 -= 2;
            }

            i4 += ai[0] * ai1[0];
            i4 = LnxmulSetDigit1(abyte5, k3, i4);
            k3 -= 2;
            LnxmulSetDigit2(abyte5, k3, i4);
            k3 -= 2;
        }
        if((i3 & 0x1) == 0 && abyte5[k3] != 1)
        {
            word0++;
            i3++;
            j3--;
        }
        for(; abyte5[(j3 + i3) - 2] == 1; i3--) { }
        if(i3 > 21)
        {
            int l3 = j3 + 19;
            i3 = 21;
            if(abyte5[l3 + 1] > 50)
            {
                while(abyte5[l3] == 100) 
                {
                    l3--;
                    i3--;
                }
                abyte5[l3]++;
            } else
            {
                for(; abyte5[(j3 + i3) - 2] == 1; i3--) { }
            }
        }
        if((word0 & 0xffff) > 255)
        {
            if(flag == flag1)
            {
                return NUMBER._makePosInf();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if((word0 & 0xffff) < 128)
        {
            return NUMBER._makeZero();
        }
        if(flag != flag1)
        {
            abyte4 = new byte[++i3];
            abyte4[0] = (byte)(~word0);
            for(int j4 = 0; j4 < i3 - 1; j4++)
            {
                abyte4[j4 + 1] = (byte)(102 - abyte5[j3 + j4]);
            }

            abyte4[i3 - 1] = 102;
        } else
        {
            abyte4 = new byte[i3];
            abyte4[0] = (byte)word0;
            for(int k4 = 0; k4 < i3 - 1; k4++)
            {
                abyte4[k4 + 1] = abyte5[j3 + k4];
            }

        }
        return abyte4;
    }

    // Decompiling method: lnxneg  Signature: ([B)[B
    // Max stack: 5, #locals: 4, #params: 2
    // Code length: 78 bytes, Code offset: 61363
    // Line Number Table found: 13 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 78 Range 0 77 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 78 Range 0 77 Init 0
    // RetValue   4 added: Name <returnValue> Type [B At 0 78 Range 0 77 Init 0 fixed
    // LocalVar   2 added: Name i Type I At 35 39 Range 35 73 Init 35
    // LocalVar   3 added: Name abyte1 Type [B At 59 14 Range 59 72 Init 59
    public byte[] lnxneg(byte abyte0[])
        throws SQLException
    {
        if(NUMBER._isZero(abyte0))
        {
            return NUMBER._makeZero();
        }
        if(NUMBER._isPosInf(abyte0))
        {
            return NUMBER._makeNegInf();
        }
        if(NUMBER._isNegInf(abyte0))
        {
            return NUMBER._makePosInf();
        }
        int i = abyte0.length;
        if(!NUMBER._isPositive(abyte0) && abyte0[i - 1] == 102)
        {
            i--;
        }
        byte abyte1[] = new byte[i];
        System.arraycopy(abyte0, 0, abyte1, 0, i);
        _negateNumber(abyte1);
        return _setLength(abyte1, i);
    }

    // Decompiling method: lnxnfn  Signature: ([BLjava/lang/String;Ljava/lang/String;)Ljava/lang/String;
    // Max stack: 5, #locals: 40, #params: 4
    // Code length: 2647 bytes, Code offset: 61537
    // Line Number Table found: 341 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 2647 Range 0 2646 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 2647 Range 0 2646 Init 0
    // Parameter  2 added: Name s Type Ljava/lang/String; At 0 2647 Range 0 2646 Init 0
    // Parameter  3 added: Name s1 Type Ljava/lang/String; At 0 2647 Range 0 2646 Init 0
    // RetValue  40 added: Name <returnValue> Type Ljava/lang/String; At 0 2647 Range 0 2646 Init 0 fixed
    // LocalVar   4 added: Name obj Type A At 1 2 Range 1 2 Init 1
    // LocalVar   7 added: Name flag Type Z At 4 2 Range 4 5 Init 4
    // LocalVar   8 added: Name flag1 Type Z At 7 2 Range 7 8 Init 7
    // LocalVar   9 added: Name flag2 Type Z At 10 2 Range 10 11 Init 10
    // LocalVar  10 added: Name flag3 Type Z At 13 2 Range 13 14 Init 13
    // LocalVar  11 added: Name flag4 Type Z At 16 2 Range 16 17 Init 16
    // LocalVar  12 added: Name flag5 Type Z At 19 2 Range 19 20 Init 19
    // LocalVar  13 added: Name flag6 Type Z At 22 2 Range 22 23 Init 22
    // LocalVar  14 added: Name flag7 Type Z At 25 2 Range 25 26 Init 25
    // LocalVar  15 added: Name flag8 Type Z At 28 2 Range 28 29 Init 28
    // LocalVar  16 added: Name flag9 Type Z At 31 2 Range 31 32 Init 31
    // LocalVar  17 added: Name flag10 Type Z At 34 2165 Range 34 2198 Init 34
    // LocalVar  18 added: Name flag11 Type Z At 37 2 Range 37 38 Init 37
    // LocalVar  19 added: Name flag12 Type Z At 40 2 Range 40 41 Init 40
    // LocalVar  20 added: Name flag13 Type Z At 43 2 Range 43 44 Init 43
    // LocalVar  21 added: Name flag14 Type Z At 46 2134 Range 46 2179 Init 46
    // LocalVar  22 added: Name flag15 Type Z At 49 2 Range 49 50 Init 49
    // LocalVar  23 added: Name flag16 Type Z At 52 2 Range 52 53 Init 52
    // LocalVar  24 added: Name flag17 Type Z At 55 2 Range 55 56 Init 55
    // LocalVar  26 added: Name obj1 Type A At 58 2139 Range 58 2196 Init 58
    // LocalVar  27 added: Name aflag Type [Z At 63 553 Range 63 615 Init 63
    // LocalVar  28 added: Name flag18 Type Z At 66 2228 Range 66 2293 Init 66
    // LocalVar  29 added: Name flag19 Type Z At 69 2 Range 69 70 Init 69
    // LocalVar  31 added: Name flag20 Type Z At 72 2163 Range 72 2234 Init 72
    // LocalVar  33 added: Name obj2 Type A At 75 2 Range 75 76 Init 75
    // LocalVar  34 added: Name lnxlibthinformat Type Loracle/sql/LnxLibThinFormat; At 84 2467 Range 84 2550 Init 84
    // LocalVar   7 added: Name i Type I At 97 1330 Range 97 1426 Init 97
    // LocalVar   8 added: Name j Type I At 104 1007 Range 104 1110 Init 104
    // LocalVar   9 added: Name k Type I At 111 2455 Range 111 2565 Init 111
    // LocalVar  10 added: Name l Type I At 118 1621 Range 118 1738 Init 118
    // LocalVar  11 added: Name i1 Type I At 125 1975 Range 125 2099 Init 125
    // LocalVar  35 added: Name j1 Type I At 185 114 Range 185 298 Init 185
    // LocalVar  36 added: Name k1 Type I At 205 63 Range 205 267 Init 205
    // LocalVar  37 added: Name l1 Type I At 238 279 Range 238 516 Init 238
    // LocalVar  38 added: Name i2 Type I At 271 244 Range 271 514 Init 271
    // LocalVar  39 added: Name flag21 Type Z At 274 140 Range 274 413 Init 274
    // LocalVar  36 added: Name j2 Type I At 301 58 Range 301 358 Init 301
    // LocalVar  39 chged: Name k2 Oname flag21 Type I At 384 2 Range 274 413 Init 274
    // LocalVar  32 added: Name flag21 Type Z At 576 133 Range 576 708 Init 576
    // LocalVar  25 added: Name abyte1 Type [B At 596 271 Range 596 866 Init 596
    // LocalVar   4 added: Name ac Type [C At 637 2003 Range 637 2639 Init 637
    // LocalVar  16 added: Name flag22 Type Z At 640 1907 Range 640 2546 Init 640
    // LocalVar  35 added: Name flag23 Type Z At 673 17 Range 673 689 Init 673
    // LocalVar  35 chged: Name l2 Oname flag23 Type I At 688 2 Range 673 689 Init 673
    // LocalVar  29 added: Name flag23 Type Z At 709 1699 Range 709 2407 Init 709
    // LocalVar  13 added: Name flag24 Type Z At 715 1531 Range 715 2245 Init 715
    // LocalVar  15 added: Name flag25 Type Z At 718 1523 Range 718 2240 Init 718
    // LocalVar  12 added: Name flag26 Type Z At 722 1634 Range 722 2355 Init 722
    // LocalVar  14 added: Name flag27 Type Z At 739 1389 Range 739 2127 Init 739
    // LocalVar  15 chged: Name i3 Oname flag25 Type I At 777 1464 Range 718 2240 Init 718
    // LocalVar  26 chged: Name abyte2 Oname obj1 Type [B At 806 1391 Range 58 2196 Init 58
    // LocalVar  35 added: Name flag25 Type Z At 822 24 Range 822 845 Init 822
    // LocalVar  35 chged: Name j3 Oname flag25 Type I At 844 2 Range 822 845 Init 822
    // LocalVar  30 added: Name flag25 Type Z At 890 235 Range 890 1124 Init 890
    // LocalVar  12 chged: Name k3 Oname flag26 Type I At 906 1450 Range 722 2355 Init 722
    // LocalVar  17 chged: Name l3 Oname flag10 Type I At 913 2 Range 34 2198 Init 34
    // LocalVar  21 chged: Name i4 Oname flag14 Type I At 950 1230 Range 46 2179 Init 46
    // LocalVar  13 chged: Name j4 Oname flag24 Type I At 991 1255 Range 715 2245 Init 715
    // LocalVar  16 chged: Name k4 Oname flag22 Type I At 1048 2 Range 640 2546 Init 640
    // LocalVar  14 chged: Name l4 Oname flag27 Type I At 1092 1036 Range 739 2127 Init 739
    // LocalVar  35 added: Name i5 Type I At 1121 134 Range 1121 1254 Init 1121
    // LocalVar  36 added: Name j5 Type I At 1140 9 Range 1140 1148 Init 1140
    // LocalVar  36 added: Name k5 Type I At 1156 104 Range 1156 1259 Init 1156
    // LocalVar  30 added: Name flag10 Type Z At 1308 72 Range 1308 1379 Init 1308
    // LocalVar  22 added: Name l5 Type I At 1442 556 Range 1442 1997 Init 1442
    // LocalVar  35 added: Name i6 Type I At 1462 25 Range 1462 1486 Init 1462
    // LocalVar  36 added: Name flag14 Type Z At 1465 20 Range 1465 1484 Init 1465
    // LocalVar  36 chged: Name j6 Oname flag14 Type I At 1483 2 Range 1465 1484 Init 1465
    // LocalVar  35 added: Name byte0 Type B At 1526 56 Range 1526 1581 Init 1526
    // LocalVar  35 chged: Name c Oname byte0 Type C At 1580 2 Range 1526 1581 Init 1526
    // LocalVar  33 added: Name s2 Type Ljava/lang/String; At 1603 797 Range 1603 2399 Init 1603
    // LocalVar  35 added: Name flag14 Type Z At 1671 25 Range 1671 1695 Init 1671
    // LocalVar  35 chged: Name k6 Oname flag14 Type I At 1694 2 Range 1671 1695 Init 1671
    // LocalVar  18 added: Name flag14 Type Z At 1705 285 Range 1705 1989 Init 1705
    // LocalVar  18 chged: Name l6 Oname flag14 Type I At 1725 2 Range 1705 1989 Init 1705
    // LocalVar  19 added: Name i7 Type I At 1710 290 Range 1710 1999 Init 1732
    // LocalVar  20 added: Name j7 Type I At 1752 62 Range 1752 1813 Init 1752
    // LocalVar  35 added: Name flag14 Type Z At 2049 25 Range 2049 2073 Init 2049
    // LocalVar  35 chged: Name k7 Oname flag14 Type I At 2072 2 Range 2049 2073 Init 2049
    // LocalVar  22 added: Name flag14 Type Z At 2096 2 Range 2096 2097 Init 2096
    // LocalVar  23 added: Name l7 Type I At 2113 154 Range 2113 2266 Init 2113
    // LocalVar  14 added: Name i8 Type I At 2129 27 Range 2129 2155 Init 2129
    // LocalVar  35 added: Name flag22 Type Z At 2373 25 Range 2373 2397 Init 2373
    // LocalVar  35 chged: Name j8 Oname flag22 Type I At 2396 2 Range 2373 2397 Init 2373
    // LocalVar  23 added: Name k8 Type I At 2547 96 Range 2547 2642 Init 2547
    // LocalVar  20 added: Name l8 Type I At 2569 28 Range 2569 2596 Init 2569
    // LocalVar  35 added: Name ac1 Type [C At 2575 38 Range 2575 2612 Init 2575
    // LocalVar  36 added: Name flag22 Type Z At 2578 17 Range 2578 2594 Init 2578
    // LocalVar  36 chged: Name i9 Oname flag22 Type I At 2593 2 Range 2578 2594 Init 2578
    // LocalVar  37 added: Name stringbuffer Type Ljava/lang/StringBuffer; At 2607 23 Range 2607 2629 Init 2607
    // LocalVar  24 added: Name j9 Type I At 1847 41 Range 1847 1887 Init 1847
    // LocalVar  24 added: Name k9 Type I At 2184 41 Range 2184 2224 Init 2184
    // LocalVar   5 hasn't been used
    // LocalVar   6 hasn't been used
    // LocalVar   4 chged: Name ac2 Oname obj Type [C At 1 2 Range 1 2 Init 1
    // LocalVar   4 name ac([C) merged out into ac2([C)
    // LocalVar   7 chged: Name l9 Oname flag Type I At 4 2 Range 4 5 Init 4
    // LocalVar   7 name i(I) merged out into l9(I)
    // LocalVar   8 chged: Name i Oname flag1 Type I At 7 2 Range 7 8 Init 7
    // LocalVar   8 name j(I) merged out into i(I)
    // LocalVar   9 chged: Name j Oname flag2 Type I At 10 2 Range 10 11 Init 10
    // LocalVar   9 name k(I) merged out into j(I)
    // LocalVar  10 chged: Name k Oname flag3 Type I At 13 2 Range 13 14 Init 13
    // LocalVar  10 name l(I) merged out into k(I)
    // LocalVar  11 chged: Name l Oname flag4 Type I At 16 2 Range 16 17 Init 16
    // LocalVar  11 name i1(I) merged out into l(I)
    // LocalVar  12 chged: Name i1 Oname flag5 Type I At 19 2 Range 19 20 Init 19
    // LocalVar  12 name k3(I) merged out into i1(I)
    // LocalVar  13 chged: Name k3 Oname flag6 Type I At 22 2 Range 22 23 Init 22
    // LocalVar  13 name j4(I) merged out into k3(I)
    // LocalVar  14 chged: Name j4 Oname flag7 Type I At 25 2 Range 25 26 Init 25
    // LocalVar  14 name l4(I) merged out into j4(I)
    // LocalVar  14 name i8(I) merged out into j4(I)
    // LocalVar  15 chged: Name l4 Oname flag8 Type I At 28 2 Range 28 29 Init 28
    // LocalVar  15 name i3(I) merged out into l4(I)
    // LocalVar  16 chged: Name i3 Oname flag9 Type I At 31 2 Range 31 32 Init 31
    // LocalVar  16 name k4(I) merged out into i3(I)
    // LocalVar  18 chged: Name k4 Oname flag11 Type I At 37 2 Range 37 38 Init 37
    // LocalVar  18 name l6(I) merged out into k4(I)
    // LocalVar  19 chged: Name l6 Oname flag12 Type I At 40 2 Range 40 41 Init 40
    // LocalVar  19 name i7(I) merged out into l6(I)
    // LocalVar  20 chged: Name i7 Oname flag13 Type I At 43 2 Range 43 44 Init 43
    // LocalVar  20 name j7(I) merged out into i7(I)
    // LocalVar  22 chged: Name j7 Oname flag15 Type I At 49 2 Range 49 50 Init 49
    // LocalVar  22 name l5(I) merged out into j7(I)
    // LocalVar  22 name flag14(Z) merged out into j7(I)
    // LocalVar  23 chged: Name l5 Oname flag16 Type I At 52 2 Range 52 53 Init 52
    // LocalVar  23 name l7(I) merged out into l5(I)
    // LocalVar  23 name k8(I) merged out into l5(I)
    // LocalVar  29 name flag23(Z) merged out into flag19(Z)
    // LocalVar  33 chged: Name s3 Oname obj2 Type Ljava/lang/String; At 75 2 Range 75 76 Init 75
    // LocalVar  33 name s2(Ljava/lang/String;) merged out into s3(Ljava/lang/String;)
    // LocalVar  36 name k5(I) merged out into j5(I)
    public String lnxnfn(byte abyte0[], String s, String s1)
        throws SQLException
    {
        char ac[] = null;
        int i = 0;
        int j = 0;
        int k = 0;
        int l = 0;
        int i1 = 0;
        int j1 = 0;
        int k1 = 0;
        int l1 = 0;
        int i2 = 0;
        int j2 = 0;
        int k2 = 0;
        int l2 = 0;
        int i3 = 0;
        int j3 = 0;
        int l3 = 0;
        int i4 = 0;
        int j4 = 0;
        boolean flag = false;
        byte abyte2[] = null;
        boolean aflag[] = new boolean[1];
        boolean flag1 = false;
        boolean flag2 = true;
        boolean flag5 = true;
        String s2 = null;
        LnxLibThinFormat lnxlibthinformat = new LnxLibThinFormat();
        lnxlibthinformat.parseFormat(s);
        i = lnxlibthinformat.lnxnflhd;
        j = lnxlibthinformat.lnxnfrhd;
        k = lnxlibthinformat.lnxnfsiz;
        l = lnxlibthinformat.lnxnfzld;
        i1 = lnxlibthinformat.lnxnfztr;
        if(lnxlibthinformat.LNXNFFRN || lnxlibthinformat.LNXNFFHX)
        {
            if(lnxlibthinformat.LNXNFFRN)
            {
                throw new SQLException(CoreException.getMessage((byte)1));
            } else
            {
                throw new SQLException(CoreException.getMessage((byte)1));
            }
        }
        if(lnxlibthinformat.LNXNFFTM)
        {
            int i5 = abyte0.length;
            int j8;
            int k8;
            int l8;
            if(!NUMBER._isZero(abyte0))
            {
                if(NUMBER._isPositive(abyte0))
                {
                    int i7 = i5 - 1;
                    j8 = 2 * ((abyte0[0] & 0xff) - 193) + ((abyte0[1] & 0xff) <= 10 ? 0 : 1);
                    k8 = 2 * i7 - ((abyte0[1] & 0xff) >= 11 ? 0 : 1) - LnxqFirstDigit[abyte0[i7]];
                    l8 = 0;
                } else
                {
                    if((abyte0[i5 - 1] & 0xff) == 102)
                    {
                        i5--;
                    }
                    int j7 = i5 - 1;
                    j8 = 2 * (62 - abyte0[0]) + ((abyte0[1] & 0xff) >= 92 ? 0 : 1);
                    k8 = 2 * j7 - ((abyte0[1] & 0xff) <= 91 ? 0 : 1) - LnxqFirstDigit[abyte0[j7]];
                    l8 = 1;
                }
            } else
            {
                j8 = 0;
                k8 = 1;
                l8 = 0;
            }
            if(j8 >= 0)
            {
                l8 += k8 <= j8 + 1 ? j8 + 1 : k8 + 1;
            } else
            {
                l8 += -(j8 + 1) + k8 + 1;
            }
            if(!lnxlibthinformat.LNXNFFSN && l8 > 64)
            {
                lnxlibthinformat.LNXNFFSN = true;
            }
            if(lnxlibthinformat.LNXNFFSN)
            {
                i = 1;
                j = k8 - 1;
                k = k8 <= 1 ? 7 : k8 + 7;
            } else
            {
                i = j8 + 1 <= 0 ? 0 : j8 + 1;
                j = k8 - (j8 + 1) <= 0 ? 0 : k8 - (j8 + 1);
                k = j == 0 ? i + 1 : i + j + 2;
            }
            if(j == 0)
            {
                lnxlibthinformat.LNXNFNRD = true;
            }
        }
        boolean flag6 = (abyte0[0] & 0xff) >= 128;
        byte abyte1[];
        if(lnxlibthinformat.LNXNFFSN)
        {
            abyte1 = lnxfpr(abyte0, j + i);
        } else
        {
            abyte1 = lnxsca(abyte0, i, j, aflag);
            if(aflag[0])
            {
                throw new SQLException(CoreException.getMessage((byte)4));
            }
        }
        ac = new char[64];
        j2 = 0;
        if(NUMBER._isZero(abyte1))
        {
            if(lnxlibthinformat.LNXNFFBL)
            {
                if(lnxlibthinformat.LNXNFFIL)
                {
                    ac = new char[k];
                    for(int j5 = 0; j5 < k; j5++)
                    {
                        ac[j5] = ' ';
                    }

                    return new String(ac);
                } else
                {
                    return null;
                }
            }
            flag2 = flag6;
            flag1 = false;
            k1 = 0;
            i2 = 0;
            j1 = k1;
            l1 = i <= 0 || i1 != 0 ? 0 : 1;
        } else
        {
            if(NUMBER._isNegInf(abyte1) || NUMBER._isPosInf(abyte1))
            {
                throw new SQLException(CoreException.getMessage((byte)4));
            }
            i2 = abyte1.length - 1;
            flag2 = (abyte1[0] & 0x80) != 0;
            if(!flag2)
            {
                abyte2 = new byte[i2];
                if(abyte1[i2] == 102)
                {
                    i2--;
                }
                for(int k5 = 1; k5 <= i2; k5++)
                {
                    abyte2[k5] = (byte)(102 - abyte1[k5]);
                }

                abyte2[0] = (byte)(~abyte1[0]);
            } else
            {
                abyte2 = abyte1;
            }
            boolean flag3 = (abyte2[i2] & 0xff) % 10 == 1;
            j1 = 2 * ((abyte2[0] & 0xff) - 192);
            k2 = 1;
            if(flag5 = (abyte2[k2] & 0xff) < 11)
            {
                l3 = ((abyte2[k2] & 0xff) - 1) / 10;
            }
            if(lnxlibthinformat.LNXNFFSN)
            {
                k1 = 2 * i2 - (flag5 ? 1 : 0) - (flag3 ? 1 : 0) - (l1 = 1);
                j1 -= (flag5 ? 1 : 0) + 1;
                if(flag1 = j1 < 0)
                {
                    j1 = -j1;
                }
                if(j1 < 100 && lnxlibthinformat.LNXNFFIL)
                {
                    ac[j2] = ' ';
                    j2++;
                }
            } else
            {
                k1 = 2 * i2 - j1 - (flag3 ? 1 : 0);
                l1 = j1 - (flag5 ? 1 : 0);
                if(lnxlibthinformat.LNXNFF05 && (j == 0 || k1 == j))
                {
                    int l5 = (k2 + i2) - 1;
                    int k7;
                    if(!flag3)
                    {
                        k7 = (abyte2[l5] & 0xff) % 10;
                        k7 = k7 == 0 ? 9 : k7 - 1;
                        if(k7 <= 2)
                        {
                            abyte2[l5] = (byte)((abyte2[l5] & 0xff) - k7);
                        } else
                        if(k7 <= 7)
                        {
                            abyte2[l5] = (byte)((abyte2[l5] & 0xff) + (5 - k7));
                        }
                    } else
                    {
                        k7 = (abyte2[l5] & 0xff) / 10;
                        if(k7 <= 2)
                        {
                            abyte2[l5] = 1;
                        } else
                        if(k7 <= 7)
                        {
                            abyte2[l5] = 51;
                        }
                    }
                    if(k7 > 7)
                    {
                        k2--;
                        abyte2 = lnxrou(abyte2, k1 - 1);
                        i2 = abyte2.length - 1;
                        boolean flag4 = (abyte2[k2] & 0xff) % 10 == 1;
                        j1 = 2 * ((abyte2[k2] & 0xff) - 192);
                        k2++;
                        if(flag5 = (abyte2[k2] & 0xff) < 11)
                        {
                            l3 = ((abyte2[k2] & 0xff) - 1) / 10;
                        }
                        k1 = 2 * i2 - j1 - (flag4 ? 1 : 0);
                        l1 = j1 - (flag5 ? 1 : 0);
                        if(l1 > i)
                        {
                            throw new SQLException(CoreException.getMessage((byte)4));
                        }
                    }
                }
            }
        }
        i4 = i - (l <= l1 ? l1 : l);
        if(i4 != 0 && lnxlibthinformat.LNXNFFIL)
        {
            int i6 = i4 + j2;
            for(int l7 = 0; l7 < i6;)
            {
                ac[l7] = ' ';
                l7++;
                j2++;
            }

        }
        if(!lnxlibthinformat.LNXNFFMI && !lnxlibthinformat.LNXNFFST)
        {
            char c;
            if(flag2)
            {
                c = lnxlibthinformat.LNXNFFSH ? '+' : ' ';
            } else
            {
                c = lnxlibthinformat.LNXNFFPR ? '<' : ((char) (lnxlibthinformat.LNXNFFPT ? '(' : '-'));
            }
            if(lnxlibthinformat.LNXNFFIL || c != ' ')
            {
                ac[j2] = c;
                j2++;
            }
        }
        if(lnxlibthinformat.LNXNFFIC)
        {
            s2 = new String("USD");
        } else
        if(lnxlibthinformat.LNXNFFUN)
        {
            s2 = new String("$");
        } else
        {
            s2 = new String("$");
        }
        if(lnxlibthinformat.LNXNFFDS)
        {
            ac[j2] = '$';
            j2++;
        } else
        if(lnxlibthinformat.LNXNFFCH)
        {
            for(int j6 = 0; j6 < s2.length();)
            {
                ac[j2] = s2.charAt(j6);
                j6++;
                j2++;
            }

        }
        for(l2 = 0; (i3 = lnxlibthinformat.lnxnfgps[l2] & 0x7f) != 0; l2++)
        {
            if(i3 > i4)
            {
                break;
            }
        }

        if((j3 = l - (l1 <= 0 ? 0 : l1)) > 0)
        {
            for(; j3 > 0; j3--)
            {
                ac[j2] = '0';
                j2++;
                for(i4++; i4 == i3; i3 = lnxlibthinformat.lnxnfgps[l2] & 0x7f)
                {
                    ac[j2] = ',';
                    j2++;
                    l2++;
                }

            }

        }
        if(l1 > 0)
        {
            while(l1 > 0 && i2 != 0) 
            {
                int k4;
                if(flag5)
                {
                    k4 = (abyte2[k2] & 0xff) - 1 - l3 * 10;
                    k2++;
                    i2--;
                } else
                {
                    k4 = ((abyte2[k2] & 0xff) - 1) / 10;
                    l3 = k4;
                }
                ac[j2] = lnx_chars[k4];
                j2++;
                for(i4++; i4 == i3; i3 = lnxlibthinformat.lnxnfgps[l2] & 0x7f)
                {
                    ac[j2] = ',';
                    j2++;
                    l2++;
                }

                l1--;
                flag5 ^= true;
            }
            for(; l1 > 0; l1--)
            {
                ac[j2] = '0';
                j2++;
                for(i4++; i4 == i3; i3 = lnxlibthinformat.lnxnfgps[l2] & 0x7f)
                {
                    ac[j2] = ',';
                    j2++;
                    l2++;
                }

            }

        }
        if(!lnxlibthinformat.LNXNFNRD)
        {
            if(lnxlibthinformat.LNXNFRDX)
            {
                ac[j2] = '.';
                j2++;
            } else
            if(lnxlibthinformat.LNXNFFRC)
            {
                for(int k6 = 0; k6 < s2.length();)
                {
                    ac[j2] = s2.charAt(k6);
                    k6++;
                    j2++;
                }

            } else
            {
                ac[j2] = '.';
                j2++;
            }
        }
        i4 = 0;
        if((j4 = i1 - (k1 <= 0 ? 0 : k1)) < 0)
        {
            j4 = 0;
        }
        if(l1 != 0)
        {
            l1 = -l1;
            k1 -= l1;
            for(; l1 != 0; l1--)
            {
                ac[j2] = '0';
                j2++;
            }

        }
        while(i2 != 0 && k1 != 0) 
        {
            int l4;
            if(flag5)
            {
                l4 = (abyte2[k2] & 0xff) - 1 - l3 * 10;
                k2++;
                i2--;
            } else
            {
                l4 = ((abyte2[k2] & 0xff) - 1) / 10;
                l3 = l4;
            }
            ac[j2] = lnx_chars[l4];
            j2++;
            k1--;
            flag5 ^= true;
        }
        for(; j4 != 0; j4--)
        {
            ac[j2] = '0';
            j2++;
        }

        if(lnxlibthinformat.LNXNFFSN)
        {
            ac[j2] = 'E';
            j2++;
            ac[j2] = flag1 ? '-' : '+';
            j2++;
            if(j1 > 99)
            {
                ac[j2] = '1';
                j2++;
                j1 -= 100;
            }
            ac[j2] = lnx_chars[j1 / 10];
            j2++;
            ac[j2] = lnx_chars[j1 % 10];
            j2++;
        }
        if(lnxlibthinformat.LNXNFFCT)
        {
            for(int l6 = 0; l6 < s2.length();)
            {
                ac[j2] = s2.charAt(l6);
                l6++;
                j2++;
            }

        }
        if(flag2)
        {
            if(lnxlibthinformat.LNXNFFST)
            {
                ac[j2] = '+';
                j2++;
            } else
            if((lnxlibthinformat.LNXNFFPR || lnxlibthinformat.LNXNFFMI || lnxlibthinformat.LNXNFFPT) && lnxlibthinformat.LNXNFFIL)
            {
                ac[j2] = ' ';
                j2++;
            }
        } else
        if(lnxlibthinformat.LNXNFFPR)
        {
            ac[j2] = '>';
            j2++;
        } else
        if(lnxlibthinformat.LNXNFFPT)
        {
            ac[j2] = ')';
            j2++;
        } else
        if(lnxlibthinformat.LNXNFFMI || lnxlibthinformat.LNXNFFST)
        {
            ac[j2] = '-';
            j2++;
        }
        j4 = j2;
        if(lnxlibthinformat.LNXNFFIL && j4 != k)
        {
            int k3 = k - j4;
            char ac1[] = new char[k3];
            for(int i8 = 0; i8 < k3; i8++)
            {
                ac1[i8] = ' ';
            }

            StringBuffer stringbuffer = new StringBuffer();
            stringbuffer.append(ac1);
            stringbuffer.append(ac, 0, j4);
            return stringbuffer.toString();
        } else
        {
            return new String(ac, 0, j4);
        }
    }

    // Decompiling method: lnxnuc  Signature: ([BILjava/lang/String;)Ljava/lang/String;
    // Max stack: 6, #locals: 34, #params: 4
    // Code length: 1917 bytes, Code offset: 65592
    // Line Number Table found: 231 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 1917 Range 0 1916 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 1917 Range 0 1916 Init 0
    // Parameter  2 added: Name i Type I At 0 1917 Range 0 1916 Init 0
    // Parameter  3 added: Name s Type Ljava/lang/String; At 0 1917 Range 0 1916 Init 0
    // RetValue  34 added: Name <returnValue> Type Ljava/lang/String; At 0 1917 Range 0 1916 Init 0 fixed
    // LocalVar   8 added: Name abyte1 Type [B At 4 1597 Range 4 1600 Init 4
    // LocalVar  24 added: Name flag Type Z At 7 1733 Range 7 1739 Init 7
    // LocalVar   4 added: Name ac Type [C At 30 1855 Range 30 1884 Init 30
    // LocalVar  16 added: Name byte0 Type B At 34 1771 Range 34 1804 Init 34
    // LocalVar   9 added: Name flag1 Type Z At 63 54 Range 63 116 Init 63
    // LocalVar  30 added: Name ac1 Type [C At 74 1839 Range 74 1912 Init 74
    // LocalVar  18 added: Name flag2 Type Z At 83 1541 Range 83 1623 Init 83
    // LocalVar   5 added: Name abyte2 Type [[B At 91 1796 Range 91 1886 Init 91
    // LocalVar  17 added: Name j Type I At 96 1073 Range 96 1168 Init 96
    // LocalVar  31 added: Name flag3 Type Z At 110 1794 Range 110 1903 Init 110
    // LocalVar  10 added: Name flag4 Type Z At 117 566 Range 117 682 Init 117
    // LocalVar  32 added: Name k Type I At 121 430 Range 121 550 Init 121
    // LocalVar  15 added: Name l Type I At 150 120 Range 150 269 Init 150
    // LocalVar  29 added: Name flag5 Type Z At 248 20 Range 248 267 Init 248
    // LocalVar  29 chged: Name i1 Oname flag5 Type I At 266 2 Range 248 267 Init 248
    // LocalVar  15 added: Name j1 Type I At 304 52 Range 304 355 Init 304
    // LocalVar  29 added: Name flag5 Type Z At 334 20 Range 334 353 Init 334
    // LocalVar  29 chged: Name k1 Oname flag5 Type I At 352 2 Range 334 353 Init 334
    // LocalVar  15 added: Name l1 Type I At 403 40 Range 403 442 Init 403
    // LocalVar  29 added: Name flag5 Type Z At 421 20 Range 421 440 Init 421
    // LocalVar  29 chged: Name i2 Oname flag5 Type I At 439 2 Range 421 440 Init 421
    // LocalVar  13 added: Name j2 Type I At 479 62 Range 479 540 Init 479
    // LocalVar  19 added: Name k2 Type I At 511 1049 Range 511 1559 Init 511
    // LocalVar  14 added: Name l2 Type I At 544 832 Range 544 1375 Init 544
    // LocalVar  13 added: Name i3 Type I At 553 63 Range 553 615 Init 553
    // LocalVar  20 added: Name j3 Type I At 709 23 Range 709 731 Init 709
    // LocalVar  15 added: Name k3 Type I At 763 398 Range 763 1160 Init 763
    // LocalVar  23 added: Name flag5 Type Z At 766 969 Range 766 1734 Init 766
    // LocalVar  25 added: Name flag6 Type Z At 783 859 Range 783 1641 Init 783
    // LocalVar  26 added: Name flag7 Type Z At 800 1076 Range 800 1875 Init 800
    // LocalVar  33 added: Name l3 Type I At 804 22 Range 804 825 Init 804
    // LocalVar  27 added: Name i4 Type I At 815 862 Range 815 1676 Init 815
    // LocalVar  28 added: Name j4 Type I At 829 989 Range 829 1817 Init 829
    // LocalVar  12 added: Name k4 Type I At 833 787 Range 833 1619 Init 833
    // LocalVar  22 added: Name l4 Type I At 854 110 Range 854 963 Init 854
    // LocalVar  11 added: Name i5 Type I At 937 12 Range 937 948 Init 937
    // LocalVar  29 added: Name flag8 Type Z At 940 22 Range 940 961 Init 940
    // LocalVar  29 chged: Name j5 Oname flag8 Type I At 960 2 Range 940 961 Init 940
    // LocalVar  21 added: Name k5 Type I At 989 137 Range 989 1125 Init 989
    // LocalVar  11 added: Name l5 Type I At 1056 75 Range 1056 1130 Init 1056
    // LocalVar  16 chged: Name c Oname byte0 Type C At 1083 2 Range 34 1804 Init 34
    // LocalVar  29 added: Name flag8 Type Z At 1095 22 Range 1095 1116 Init 1095
    // LocalVar  29 chged: Name i6 Oname flag8 Type I At 1115 2 Range 1095 1116 Init 1095
    // LocalVar  29 added: Name flag8 Type Z At 1139 20 Range 1139 1158 Init 1139
    // LocalVar  29 chged: Name j6 Oname flag8 Type I At 1157 2 Range 1139 1158 Init 1139
    // LocalVar  20 added: Name k6 Type I At 1190 91 Range 1190 1280 Init 1190
    // LocalVar  22 added: Name l6 Type I At 1242 174 Range 1242 1415 Init 1242
    // LocalVar  11 added: Name i7 Type I At 1377 215 Range 1377 1591 Init 1377
    // LocalVar  29 added: Name flag8 Type Z At 1385 22 Range 1385 1406 Init 1385
    // LocalVar  29 chged: Name j7 Oname flag8 Type I At 1405 2 Range 1385 1406 Init 1385
    // LocalVar   6 added: Name flag8 Type Z At 1616 286 Range 1616 1901 Init 1616
    // LocalVar  11 added: Name k7 Type I At 1620 279 Range 1620 1898 Init 1620
    // LocalVar   6 chged: Name l7 Oname flag8 Type I At 1654 2 Range 1616 1901 Init 1616
    // LocalVar   7 added: Name i8 Type I At 1678 52 Range 1678 1729 Init 1678
    // LocalVar   7 added: Name j8 Type I At 1819 52 Range 1819 1870 Init 1819
    public String lnxnuc(byte abyte0[], int i, String s)
        throws SQLException
    {
        byte abyte2[] = new byte[22];
        boolean flag4 = false;
        if(s != null)
        {
            throw new SQLException(CoreException.getMessage((byte)12));
        }
        char ac[] = lnx_chars;
        char c = '.';
        if(i == 0)
        {
            throw new SQLException(CoreException.getMessage((byte)13));
        }
        boolean flag;
        if(!(flag = i >= 0))
        {
            i = -i;
        }
        char ac1[] = new char[i];
        byte abyte1[][];
        int i4;
        boolean flag2;
        if(flag2 = NUMBER._isPositive(abyte0) ^ true)
        {
            abyte1 = LnxqComponents_N;
            i4 = i - 1;
        } else
        {
            abyte1 = LnxqComponents_P;
            i4 = i;
        }
        boolean flag7 = true;
        while(flag7) 
        {
            boolean flag1 = flag;
            int i8 = abyte0.length;
            if(i8 == 1)
            {
                if((abyte0[0] & 0xff) == 128)
                {
                    int i3;
                    if(flag1)
                    {
                        i3 = i - 1;
                        ac1[i3] = ac[0];
                    } else
                    {
                        if(i < 5)
                        {
                            throw new SQLException(CoreException.getMessage((byte)13));
                        }
                        i3 = i - 5;
                        ac1[i3] = ac[0];
                        ac1[i3 + 1] = ac[41];
                        ac1[i3 + 2] = ac[10];
                        ac1[i3 + 3] = ac[0];
                        ac1[i3 + 4] = ac[0];
                    }
                    if(i3 != 0)
                    {
                        for(int j6 = 0; j6 < i3; j6++)
                        {
                            ac1[j6] = ac[12];
                        }

                    }
                    return new String(ac1);
                }
                if(i < 2)
                {
                    throw new SQLException(CoreException.getMessage((byte)13));
                }
                int j3 = i - 2;
                ac1[j3] = ac[11];
                ac1[j3 + 1] = ac[21];
                if(j3 != 0)
                {
                    for(int k6 = 0; k6 < j3; k6++)
                    {
                        ac1[k6] = ac[12];
                    }

                }
                return new String(ac1);
            }
            if(i8 == 2 && (abyte0[0] & 0xff) == 255 && (abyte0[1] & 0xff) == 101)
            {
                int k3 = i - 1;
                ac1[k3] = ac[21];
                if(k3 != 0)
                {
                    for(int l6 = 0; l6 < k3; l6++)
                    {
                        ac1[l6] = ac[12];
                    }

                }
                return new String(ac1);
            }
            int l2;
            int j4;
            if(flag2)
            {
                if(abyte0[i8 - 1] == 102)
                {
                    i8--;
                }
                int j2 = i8 - 1;
                j4 = 2 * (62 - (abyte0[0] & 0xff)) + ((abyte0[1] & 0xff) >= 92 ? 0 : 1);
                l2 = 2 * j2 - ((abyte0[1] & 0xff) <= 91 ? 0 : 1) - LnxqFirstDigit[abyte0[j2]];
            } else
            {
                int k2 = i8 - 1;
                j4 = 2 * ((abyte0[0] & 0xff) - 193) + ((abyte0[1] & 0xff) <= 10 ? 0 : 1);
                l2 = 2 * k2 - ((abyte0[1] & 0xff) >= 11 ? 0 : 1) - LnxqFirstDigit[abyte0[k2]];
            }
            if(flag1)
            {
                if(j4 >= 0)
                {
                    flag1 = j4 < i4;
                } else
                {
                    flag1 = (j4 < -5 && l2 - j4 > i4 && i4 > 6) ^ true;
                }
            }
            int i2;
            boolean flag3;
            boolean flag5;
            boolean flag6;
            int l5;
            int i6;
            if(flag1)
            {
                int k4;
                if(j4 >= 0)
                {
                    k4 = i4 > j4 + 1 ? i4 - 1 : i4;
                } else
                {
                    k4 = i4 + j4;
                }
                if(k4 < l2)
                {
                    abyte0 = lnxfpr(abyte0, k4);
                    continue;
                }
                flag7 = false;
                int l3;
                if(j4 >= 0)
                {
                    if(l2 > j4 + 1)
                    {
                        l3 = i4 - (l2 + 1);
                        flag3 = true;
                        flag4 = false;
                        flag5 = (j4 & 0x1) <= 0;
                        flag6 = (l2 - j4 & 0x1) <= 0;
                        int j8 = 0x7fffffff;
                        l5 = j4 + 1 & j8 - 1;
                        i6 = l2 - (j4 + 1) & j8 - 1;
                        i2 = l3;
                    } else
                    {
                        l3 = i4 - (j4 + 1);
                        int j5 = (j4 + 1) - l2;
                        flag3 = false;
                        flag5 = (j4 & 0x1) <= 0;
                        flag6 = (j5 & 0x1) > 0;
                        l5 = l2 - (flag5 ? 1 : 0) - (flag6 ? 1 : 0);
                        i6 = 0;
                        if(j5 != 0)
                        {
                            int i1 = l3 + (flag2 ? 1 : 0) + l2;
                            for(int i7 = 0; i7 < j5; i7++)
                            {
                                ac1[i1 + i7] = ac[0];
                            }

                        }
                        i2 = l3;
                    }
                } else
                {
                    l3 = i4 - (l2 - j4);
                    int i5 = -(j4 + 1);
                    flag3 = false;
                    flag5 = (i5 & 0x1) > 0;
                    flag6 = (i5 + l2 & 0x1) > 0;
                    l5 = 0;
                    i6 = l2 - (flag5 ? 1 : 0) - (flag6 ? 1 : 0);
                    int j1 = l3;
                    if(flag2)
                    {
                        ac1[j1] = ac[11];
                        j1++;
                        flag2 = false;
                    }
                    ac1[j1] = c;
                    j1++;
                    if(i5 != 0)
                    {
                        for(int j7 = 0; j7 < i5; j7++)
                        {
                            ac1[j1 + j7] = ac[0];
                        }

                        j1 += i5;
                    }
                    i2 = j1;
                }
                if(l3 != 0)
                {
                    for(int k7 = 0; k7 < l3; k7++)
                    {
                        ac1[k7] = ac[12];
                    }

                }
            } else
            {
                int l4 = i4 - (j4 <= 99 && j4 >= -99 ? 5 : 6);
                if(l4 < 2)
                {
                    throw new SQLException(CoreException.getMessage((byte)13));
                }
                if(l4 < l2)
                {
                    abyte0 = lnxfpr(abyte0, l4);
                    continue;
                }
                flag7 = false;
                int k5;
                if(l2 == 1)
                {
                    k5 = l4 - 1;
                    flag3 = true;
                    flag4 = (j4 & 0x1) > 0;
                    flag5 = flag4 ^ true;
                    flag6 = false;
                    l5 = 0;
                    i6 = 0;
                } else
                {
                    k5 = l4 - l2;
                    flag3 = true;
                    flag4 = (j4 & 0x1) > 0;
                    flag5 = flag4 ^ true;
                    flag6 = flag4 == ((l2 & 0x1) > 0);
                    l5 = 0;
                    i6 = l2 - (flag5 ? 1 : 2) - (flag6 ? 1 : 0);
                }
                int k1 = (flag2 ? 1 : 0) + 1 + l2;
                if(k5 != 0)
                {
                    for(int l7 = 0; l7 < k5; l7++)
                    {
                        ac1[k1 + l7] = ac[0];
                    }

                    k1 += k5;
                }
                if(j4 < 0)
                {
                    j4 = -j4;
                    ac1[k1] = ac[41];
                    ac1[k1 + 1] = ac[11];
                } else
                {
                    ac1[k1] = ac[41];
                    ac1[k1 + 1] = ac[10];
                }
                if(j4 > 99)
                {
                    ac1[k1 + 2] = ac[1];
                    abyte2[0] = (byte)(j4 - 99);
                    ac1[k1 + 3] = ac[LnxqComponents_P[abyte2[0] & 0xff][0]];
                    ac1[k1 + 4] = ac[LnxqComponents_P[abyte2[0] & 0xff][1]];
                } else
                {
                    abyte2[0] = (byte)(j4 + 1);
                    ac1[k1 + 2] = ac[LnxqComponents_P[abyte2[0] & 0xff][0]];
                    ac1[k1 + 3] = ac[LnxqComponents_P[abyte2[0] & 0xff][1]];
                }
                i2 = 0;
            }
            int j = 1;
            int l1 = i2;
            if(flag2)
            {
                ac1[l1] = ac[11];
                l1++;
            }
            if(flag5)
            {
                ac1[l1] = ac[abyte1[abyte0[j]][1]];
                l1++;
                j++;
            }
            if(l5 != 0)
            {
                for(int k = l1 + l5; l1 < k;)
                {
                    ac1[l1] = ac[abyte1[abyte0[j]][0]];
                    l1++;
                    ac1[l1] = ac[abyte1[abyte0[j]][1]];
                    l1++;
                    j++;
                }

            }
            if(flag3)
            {
                if(flag4)
                {
                    ac1[l1] = ac[abyte1[abyte0[j]][0]];
                    l1++;
                    ac1[l1] = c;
                    l1++;
                    ac1[l1] = ac[abyte1[abyte0[j]][1]];
                    l1++;
                    j++;
                } else
                {
                    ac1[l1] = c;
                    l1++;
                }
            }
            if(i6 != 0)
            {
                for(int l = l1 + i6; l1 < l;)
                {
                    ac1[l1] = ac[abyte1[abyte0[j]][0]];
                    l1++;
                    ac1[l1] = ac[abyte1[abyte0[j]][1]];
                    l1++;
                    j++;
                }

            }
            if(flag6)
            {
                ac1[l1] = ac[abyte1[abyte0[j]][0]];
                l1++;
                j++;
            }
        }
        return new String(ac1);
    }

    // Decompiling method: lnxnur  Signature: ([B)D
    // Max stack: 6, #locals: 23, #params: 2
    // Code length: 784 bytes, Code offset: 68477
    // Line Number Table found: 100 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 784 Range 0 783 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 784 Range 0 783 Init 0
    // RetValue  23 added: Name <returnValue> Type D At 0 784 Range 0 783 Init 0 fixed
    // LocalVar   2 added: Name d Type D At 1 1 Range 1 1 Init 1
    // LocalVar   5 added: Name flag Type Z At 3 639 Range 3 641 Init 3
    // LocalVar  11 added: Name flag1 Type Z At 6 545 Range 6 550 Init 6
    // LocalVar  17 added: Name i Type I At 12 102 Range 12 113 Init 12
    // LocalVar  18 added: Name abyte1 Type [B At 18 622 Range 18 639 Init 18
    // LocalVar  12 added: Name flag2 Type Z At 34 522 Range 34 555 Init 34
    // LocalVar  19 added: Name d1 Type D At 43 94 Range 43 136 Init 43
    // LocalVar  21 added: Name d2 Type D At 59 68 Range 59 126 Init 59
    // LocalVar   4 added: Name byte0 Type B At 95 560 Range 95 654 Init 95
    // LocalVar  15 added: Name j Type I At 106 661 Range 106 766 Init 106
    // LocalVar   4 chged: Name k Oname byte0 Type I At 118 537 Range 95 654 Init 95
    // LocalVar  10 added: Name l Type I At 155 391 Range 155 545 Init 155
    // LocalVar   7 added: Name i1 Type I At 244 40 Range 244 283 Init 244
    // LocalVar  13 added: Name d3 Type D At 257 4 Range 257 260 Init 257
    // LocalVar   2 added: Name d4 Type D At 278 504 Range 278 781 Init 278
    // LocalVar   5 chged: Name j1 Oname flag Type I At 295 3 Range 3 641 Init 3
    // LocalVar   7 added: Name k1 Type I At 316 40 Range 316 355 Init 316
    // LocalVar  13 added: Name d5 Type D At 329 4 Range 329 332 Init 329
    // LocalVar   7 added: Name byte0 Type B At 380 40 Range 380 419 Init 380
    // LocalVar  13 added: Name d6 Type D At 393 4 Range 393 396 Init 393
    // LocalVar   7 chged: Name l1 Oname byte0 Type I At 402 2 Range 380 419 Init 380
    // LocalVar   7 added: Name flag Type Z At 570 5 Range 570 574 Init 570
    // LocalVar   7 chged: Name i2 Oname flag Type I At 573 2 Range 570 574 Init 570
    // LocalVar   7 added: Name j2 Type I At 618 20 Range 618 637 Init 618
    // LocalVar   7 added: Name k2 Type I At 644 5 Range 644 648 Init 644
    // LocalVar   6 added: Name flag Type Z At 667 98 Range 667 764 Init 667
    // LocalVar   7 added: Name l2 Type I At 483 43 Range 483 525 Init 483
    // LocalVar  13 added: Name d7 Type D At 496 4 Range 496 499 Init 496
    // LocalVar   6 chged: Name i3 Oname flag Type I At 675 2 Range 667 764 Init 667
    // LocalVar   8 hasn't been used
    // LocalVar   9 hasn't been used
    // LocalVar  16 hasn't been used
    // LocalVar   2 name d4(D) merged out into d(D)
    // LocalVar   7 name k2(I) merged out into j2(I)
    public double lnxnur(byte abyte0[])
    {
        double d = 0.0D;
        int j = 1;
        boolean flag = false;
        int l2 = factorTable.length;
        byte abyte1[] = NUMBER._fromLnxFmt(abyte0);
        boolean flag1 = abyte1[1] < 10;
        double d5 = factorTable[0][0];
        double d6 = factorTable[0][0] - (double)(l2 - 20);
        int i;
        int k2;
        if((double)abyte1[0] > d5 || (double)abyte1[0] < d6)
        {
            if((double)abyte1[0] > d5)
            {
                i = -1;
                k2 = (int)((double)abyte1[0] - d5);
            } else
            {
                i = -1 + (l2 - 20);
                k2 = (int)((double)abyte1[0] - d6);
            }
        } else
        {
            i = -1 + (int)(d5 - (double)abyte1[0]);
            k2 = 0;
        }
        int j2 = abyte1.length - 1;
        if(flag1 ? j2 > 8 || false : j2 >= 8 || false)
        {
            j2 = 8;
            flag = true;
        }
        switch(j2 % 4)
        {
        case 3: // '\003'
            int l = (abyte1[1] * 100 + abyte1[2]) * 100 + abyte1[3];
            i += 3;
            double d1 = factorTable[i][1];
            if(d1 < 1.0D)
            {
                d = (double)l / factorTable[i][2];
            } else
            {
                d = (double)l * factorTable[i][1];
            }
            j += 3;
            j2 -= 3;
            break;

        case 2: // '\002'
            int i1 = abyte1[1] * 100 + abyte1[2];
            i += 2;
            double d2 = factorTable[i][1];
            if(d2 < 1.0D)
            {
                d = (double)i1 / factorTable[i][2];
            } else
            {
                d = (double)i1 * factorTable[i][1];
            }
            j += 2;
            j2 -= 2;
            break;

        case 1: // '\001'
            int j1 = abyte1[1];
            i++;
            double d3 = factorTable[i][1];
            if(d3 < 1.0D)
            {
                d = (double)j1 / factorTable[i][2];
            } else
            {
                d = (double)j1 * factorTable[i][1];
            }
            j++;
            j2--;
            break;

        default:
            d = 0.0D;
            break;
        }
        for(; j2 > 0; j2 -= 4)
        {
            int k1 = ((abyte1[j] * 100 + abyte1[j + 1]) * 100 + abyte1[j + 2]) * 100 + abyte1[j + 3];
            i += 4;
            double d4 = factorTable[i][1];
            if(d4 < 1.0D)
            {
                d += (double)k1 / factorTable[i][2];
            } else
            {
                d += (double)k1 * factorTable[i][1];
            }
            j += 4;
        }

        if(flag)
        {
            if(flag1)
            {
                if(abyte1[j] > 50)
                {
                    int l1 = 1;
                    d += (double)l1 * factorTable[i][1];
                }
            } else
            {
                j--;
                int i2;
                if(abyte1[j] % 10 >= 5)
                {
                    i2 = (abyte1[j] / 10 + 1) * 10;
                } else
                {
                    i2 = (abyte1[j] / 10) * 10;
                }
                i2 -= abyte1[j];
                d += (double)i2 * factorTable[i][1];
            }
        }
        if(k2 != 0)
        {
            int k;
            for(k = 0; k2 > 0; k++)
            {
                if((int)powerTable[k][0] <= k2)
                {
                    k2 -= (int)powerTable[k][0];
                    d *= powerTable[k][1];
                }
            }

            while(k2 < 0) 
            {
                if((int)powerTable[k][0] <= -k2)
                {
                    k2 += (int)powerTable[k][0];
                    d *= powerTable[k][2];
                }
                k++;
            }
        }
        return NUMBER._isPositive(abyte0) ? d : -d;
    }

    // Decompiling method: lnxpow  Signature: ([BI)[B
    // Max stack: 5, #locals: 5, #params: 3
    // Code length: 106 bytes, Code offset: 69695
    // Line Number Table found: 18 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 106 Range 0 105 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 106 Range 0 105 Init 0
    // Parameter  2 added: Name i Type I At 0 106 Range 0 105 Init 0
    // RetValue   5 added: Name <returnValue> Type [B At 0 106 Range 0 105 Init 0 fixed
    // LocalVar   3 added: Name abyte1 Type [B At 8 87 Range 8 94 Init 8
    // LocalVar   4 added: Name j Type I At 23 12 Range 23 34 Init 23
    // LocalVar   4 added: Name abyte2 Type [B At 63 42 Range 63 104 Init 63
    public byte[] lnxpow(byte abyte0[], int i)
        throws SQLException
    {
        byte abyte1[];
        if(i >= 0)
        {
            abyte1 = new byte[abyte0.length];
            System.arraycopy(abyte0, 0, abyte1, 0, abyte0.length);
        } else
        {
            int j = 0x80000000;
            if(i == j)
            {
                abyte1 = lnxpow(abyte0, j + 1);
                return lnxdiv(abyte1, abyte0);
            }
            i = -i;
            abyte1 = lnxdiv(lnxqone, abyte0);
        }
        byte abyte2[] = lnxqone;
        while(i > 0) 
        {
            if((i & 0x1) == 1)
            {
                abyte2 = lnxmul(abyte2, abyte1);
            }
            if((i >>= 1) > 0)
            {
                abyte1 = lnxmul(abyte1, abyte1);
            }
        }
        return abyte2;
    }

    // Decompiling method: lnxqIDiv  Signature: ([BI)[B
    // Max stack: 3, #locals: 4, #params: 3
    // Code length: 14 bytes, Code offset: 69917
    // Line Number Table found: 2 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 14 Range 0 13 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 14 Range 0 13 Init 0
    // Parameter  2 added: Name i Type I At 0 14 Range 0 13 Init 0
    // RetValue   4 added: Name <returnValue> Type [B At 0 14 Range 0 13 Init 0 fixed
    // LocalVar   3 added: Name abyte1 Type [B At 6 4 Range 6 9 Init 6
    private byte[] lnxqIDiv(byte abyte0[], int i)
        throws SQLException
    {
        byte abyte1[] = lnxmin(i);
        return lnxdiv(abyte0, abyte1);
    }

    // Decompiling method: lnxqctn  Signature: (C)I
    // Max stack: 2, #locals: 1, #params: 1
    // Code length: 7 bytes, Code offset: 69983
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name c Type C At 0 7 Range 0 6 Init 0
    // RetValue   1 added: Name <returnValue> Type I At 0 7 Range 0 6 Init 0 fixed
    private static int lnxqctn(char c)
    {
        return Character.digit(c, 10);
    }

    // Decompiling method: lnxqh2n  Signature: ([C)[B
    // Max stack: 7, #locals: 24, #params: 2
    // Code length: 806 bytes, Code offset: 70028
    // Line Number Table found: 103 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 806 Range 0 805 Init 0 fixed
    // Parameter  1 added: Name ac Type [C At 0 806 Range 0 805 Init 0
    // RetValue  24 added: Name <returnValue> Type [B At 0 806 Range 0 805 Init 0 fixed
    // LocalVar   2 added: Name byte0 Type B At 2 1 Range 2 2 Init 2
    // LocalVar   3 added: Name byte1 Type B At 5 1 Range 5 5 Init 5
    // LocalVar   4 added: Name byte2 Type B At 8 2 Range 8 9 Init 8
    // LocalVar   5 added: Name byte3 Type B At 12 2 Range 12 13 Init 12
    // LocalVar   6 added: Name byte4 Type B At 16 2 Range 16 17 Init 16
    // LocalVar   7 added: Name flag Type Z At 19 312 Range 19 330 Init 19
    // LocalVar   8 added: Name i Type I At 23 313 Range 23 335 Init 23
    // LocalVar   9 added: Name al Type [J At 29 584 Range 29 612 Init 29
    // LocalVar  10 added: Name byte5 Type B At 33 523 Range 33 555 Init 33
    // LocalVar  11 added: Name byte6 Type B At 37 598 Range 37 634 Init 37
    // LocalVar  13 added: Name abyte0 Type [B At 43 699 Range 43 741 Init 43
    // LocalVar  14 added: Name flag1 Type Z At 46 698 Range 46 743 Init 46
    // LocalVar   7 chged: Name j Oname flag Type I At 83 2 Range 19 330 Init 19
    // LocalVar  18 added: Name k Type I At 348 4 Range 348 351 Init 348
    // LocalVar  18 added: Name l Type I At 370 4 Range 370 373 Init 370
    // LocalVar  18 added: Name i1 Type I At 392 248 Range 392 639 Init 392
    // LocalVar  21 added: Name abyte1 Type [B At 398 396 Range 398 793 Init 398
    // LocalVar  22 added: Name flag Type Z At 401 360 Range 401 760 Init 401
    // LocalVar  22 chged: Name j1 Oname flag Type I At 405 2 Range 401 760 Init 401
    // LocalVar  16 added: Name abyte2 Type [B At 424 355 Range 424 778 Init 424
    // LocalVar  15 added: Name flag Type Z At 428 200 Range 428 627 Init 428
    // LocalVar  17 added: Name byte7 Type B At 432 368 Range 432 799 Init 432
    // LocalVar  15 chged: Name k1 Oname flag Type I At 445 183 Range 428 627 Init 428
    // LocalVar  17 chged: Name l1 Oname byte7 Type I At 451 349 Range 432 799 Init 432
    // LocalVar  12 added: Name i2 Type I At 558 75 Range 558 632 Init 558
    // LocalVar  14 chged: Name j2 Oname flag1 Type I At 645 2 Range 46 743 Init 46
    // LocalVar  15 added: Name k2 Type I At 650 54 Range 650 703 Init 650
    // LocalVar  23 added: Name flag Type Z At 726 28 Range 726 753 Init 726
    // LocalVar  23 chged: Name l2 Oname flag Type I At 752 2 Range 726 753 Init 726
    // LocalVar  15 added: Name i3 Type I At 766 15 Range 766 780 Init 766
    // LocalVar  23 added: Name abyte3 Type [B At 790 15 Range 790 804 Init 790
    // LocalVar  19 added: Name l3 Type J At 216 11 Range 216 226 Init 216
    // LocalVar  19 added: Name l4 Type J At 230 12 Range 230 241 Init 230
    // LocalVar  19 added: Name l5 Type J At 245 12 Range 245 256 Init 245
    // LocalVar  19 added: Name l6 Type J At 260 67 Range 260 326 Init 260
    // LocalVar  12 added: Name byte7 Type B At 264 42 Range 264 305 Init 264
    // LocalVar  10 chged: Name j3 Oname byte5 Type I At 318 3 Range 33 555 Init 33
    // LocalVar  12 chged: Name k3 Oname byte7 Type I At 301 3 Range 264 305 Init 264
    // LocalVar  18 name l(I) merged out into k(I)
    // LocalVar  18 name i1(I) merged out into k(I)
    // LocalVar  19 name l4(J) merged out into l3(J)
    // LocalVar  19 name l5(J) merged out into l3(J)
    // LocalVar  19 name l6(J) merged out into l3(J)
    private byte[] lnxqh2n(char ac[])
    {
        byte byte0 = 65;
        byte byte1 = 97;
        byte byte2 = 70;
        byte byte3 = 102;
        byte byte4 = 48;
        int i = 0;
        int j = ac.length;
        long al[] = new long[14];
        int k = 13;
        byte byte5 = 13;
        byte abyte0[] = new byte[42];
        int j1 = 1;
        for(; j != 0 && ac[j - 1] == 0; j--) { }
        for(; j != 0 && ac[i] == '0'; j--)
        {
            i++;
        }

        if(j == 0)
        {
            return NUMBER._makeZero();
        }
        al[byte5] = 0L;
        switch(j % 3)
        {
        case 0: // '\0'
            al[byte5] = LNXQH2N_DIGIT(ac[i], 8, al[byte5]);
            i++;
            j--;
            // fall through

        case 2: // '\002'
            al[byte5] = LNXQH2N_DIGIT(ac[i], 4, al[byte5]);
            i++;
            j--;
            // fall through

        case 1: // '\001'
            al[byte5] = LNXQH2N_DIGIT(ac[i], 0, al[byte5]);
            i++;
            j--;
            break;
        }
        for(; j != 0; j -= 3)
        {
            long l2 = 0L;
            l2 = LNXQH2N_DIGIT(ac[i], 8, l2);
            l2 = LNXQH2N_DIGIT(ac[i + 1], 4, l2);
            l2 = LNXQH2N_DIGIT(ac[i + 2], 0, l2);
            for(int l = byte5; l >= k; l--)
            {
                l2 += al[l] << 12;
                al[l] = l2 % 0x0000f4240L;
                l2 /= 0x0000f4240L;
            }

            if(l2 != 0L)
            {
                k--;
                al[k] = l2;
            }
            i += 3;
        }

        int k2 = 3 * (byte5 - k) + 1;
        k2 += al[k] < 100L ? 0 : 1;
        k2 += al[k] < 10000L ? 0 : 1;
        byte abyte2[] = new byte[22];
        int i3 = 0;
        abyte2[i3] = (byte)(k2 + 192);
        int k1;
        byte abyte1[];
        int j2;
        if(k2 > 20)
        {
            abyte1 = abyte0;
            k1 = j1;
            j2 = 21;
        } else
        {
            abyte1 = abyte2;
            k1 = i3 + 1;
            j2 = k2 + 1;
        }
        int i1;
        switch(k2 % 3)
        {
        case 0: // '\0'
            abyte1[k1] = (byte)(int)(al[k] / 10000L + 1L);
            k1++;
            // fall through

        case 2: // '\002'
            abyte1[k1] = (byte)(int)((al[k] % 10000L) / 100L + 1L);
            k1++;
            // fall through

        case 1: // '\001'
            abyte1[k1] = (byte)(int)(al[k] % 100L + 1L);
            k1++;
            // fall through

        default:
            i1 = k + 1;
            break;
        }
        for(; i1 <= byte5; i1++)
        {
            abyte1[k1] = (byte)(int)(al[i1] / 10000L + 1L);
            abyte1[k1 + 1] = (byte)(int)((al[i1] % 10000L) / 100L + 1L);
            abyte1[k1 + 2] = (byte)(int)(al[i1] % 100L + 1L);
            k1 += 3;
        }

        if(k2 > 20)
        {
            int l1 = j1 + 20;
            if(abyte0[l1] > 50)
            {
                abyte0[j1 - 1] = 1;
                for(l1--; abyte0[l1] == 100;)
                {
                    l1--;
                    j2--;
                }

                abyte0[l1]++;
                if(l1 < j1)
                {
                    j1--;
                    abyte2[i3]++;
                    j2 = 2;
                }
            }
            for(int j3 = 0; j3 < j2; j3++)
            {
                abyte2[i3 + 1 + j3] = abyte0[j1 + j3];
            }

        }
        for(int i2 = i3 + (j2 - 1); abyte1[i2] == 1;)
        {
            i2--;
            j2--;
        }

        byte abyte3[] = new byte[j2];
        System.arraycopy(abyte2, 0, abyte3, 0, j2);
        return abyte3;
    }

    // Decompiling method: lnxqtra  Signature: ([BI)[B
    // Max stack: 5, #locals: 19, #params: 3
    // Code length: 890 bytes, Code offset: 71280
    // Line Number Table found: 109 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 890 Range 0 889 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 890 Range 0 889 Init 0
    // Parameter  2 added: Name i Type I At 0 890 Range 0 889 Init 0
    // RetValue  19 added: Name <returnValue> Type [B At 0 890 Range 0 889 Init 0 fixed
    // LocalVar   3 added: Name obj Type A At 1 1 Range 1 1 Init 1
    // LocalVar   4 added: Name obj1 Type A At 3 2 Range 3 4 Init 3
    // LocalVar   5 added: Name obj2 Type A At 6 2 Range 6 7 Init 6
    // LocalVar   6 added: Name abyte1 Type [B At 14 58 Range 14 71 Init 14
    // LocalVar   7 added: Name abyte2 Type [B At 23 743 Range 23 765 Init 23
    // LocalVar   8 added: Name l Type J At 26 847 Range 26 872 Init 26
    // LocalVar   5 added: Name abyte3 Type [B At 52 30 Range 52 81 Init 52
    // LocalVar   3 added: Name abyte4 Type [B At 59 3 Range 59 61 Init 59
    // LocalVar   3 added: Name abyte5 Type [B At 67 351 Range 67 417 Init 67
    // LocalVar   4 added: Name abyte6 Type [B At 107 370 Range 107 476 Init 107
    // LocalVar   5 added: Name abyte7 Type [B At 133 40 Range 133 172 Init 133
    // LocalVar  10 added: Name obj3 Type A At 212 616 Range 212 827 Init 212
    // LocalVar  11 added: Name obj4 Type A At 215 615 Range 215 829 Init 215
    // LocalVar   5 added: Name abyte8 Type [B At 231 20 Range 231 250 Init 231
    // LocalVar  10 chged: Name abyte9 Oname obj3 Type [B At 236 91 Range 212 827 Init 212
    // LocalVar  11 chged: Name abyte10 Oname obj4 Type [B At 241 42 Range 215 829 Init 215
    // LocalVar  13 added: Name flag Type Z At 244 70 Range 244 313 Init 244
    // LocalVar   5 added: Name abyte11 Type [B At 254 19 Range 254 272 Init 254
    // LocalVar  13 chged: Name j Oname flag Type I At 256 2 Range 244 313 Init 244
    // LocalVar  12 added: Name k Type I At 265 10 Range 265 274 Init 265
    // LocalVar   5 added: Name abyte12 Type [B At 278 17 Range 278 294 Init 278
    // LocalVar   5 added: Name abyte13 Type [B At 298 19 Range 298 316 Init 298
    // LocalVar  12 added: Name i1 Type I At 309 10 Range 309 318 Init 309
    // LocalVar   5 name abyte11([B) merged out into abyte8([B)
    // LocalVar   5 name abyte12([B) merged out into abyte8([B)
    // LocalVar   5 name abyte13([B) merged out into abyte8([B)
    // LocalVar  13 added: Name obj3 Type A At 374 444 Range 374 817 Init 374
    // LocalVar  14 added: Name obj4 Type A At 377 443 Range 377 819 Init 377
    // LocalVar   5 added: Name abyte11 Type [B At 394 41 Range 394 434 Init 394
    // LocalVar  13 chged: Name abyte12 Oname obj3 Type [B At 410 101 Range 374 817 Init 374
    // LocalVar  14 chged: Name abyte13 Oname obj4 Type [B At 425 42 Range 377 819 Init 377
    // LocalVar  15 added: Name flag Type Z At 428 70 Range 428 497 Init 428
    // LocalVar   5 added: Name abyte14 Type [B At 438 19 Range 438 456 Init 438
    // LocalVar  15 chged: Name j1 Oname flag Type I At 440 2 Range 428 497 Init 428
    // LocalVar  12 added: Name k1 Type I At 449 10 Range 449 458 Init 449
    // LocalVar   5 added: Name abyte15 Type [B At 462 17 Range 462 478 Init 462
    // LocalVar   5 added: Name abyte16 Type [B At 482 19 Range 482 500 Init 482
    // LocalVar  12 added: Name l1 Type I At 493 10 Range 493 502 Init 493
    // LocalVar   5 name abyte14([B) merged out into abyte11([B)
    // LocalVar   5 name abyte15([B) merged out into abyte11([B)
    // LocalVar   5 name abyte16([B) merged out into abyte11([B)
    // LocalVar  15 added: Name obj3 Type A At 640 141 Range 640 780 Init 640
    // LocalVar  16 added: Name obj4 Type A At 643 2 Range 643 644 Init 643
    // LocalVar  15 chged: Name abyte14 Oname obj3 Type [B At 678 103 Range 640 780 Init 640
    // LocalVar  16 added: Name abyte15 Type [B At 731 48 Range 731 778 Init 731
    // LocalVar  16 added: Name abyte16 Type [B At 823 40 Range 823 862 Init 823
    // LocalVar  15 added: Name abyte17 Type [B At 833 28 Range 833 860 Init 833
    // LocalVar  17 added: Name abyte18 Type [B At 856 15 Range 856 870 Init 856
    // LocalVar  18 added: Name abyte19 Type [B At 866 15 Range 866 880 Init 866
    // LocalVar   3 added: Name abyte20 Type [B At 877 5 Range 877 881 Init 877
    // LocalVar  18 added: Name abyte21 Type [B At 885 4 Range 885 888 Init 885
    // LocalVar   3 chged: Name abyte22 Oname obj Type [B At 1 1 Range 1 1 Init 1
    // LocalVar   3 name abyte5([B) merged out into abyte22([B)
    // LocalVar   3 name abyte4([B) merged out into abyte22([B)
    // LocalVar   4 chged: Name abyte4 Oname obj1 Type [B At 3 2 Range 3 4 Init 3
    // LocalVar   4 name abyte6([B) merged out into abyte4([B)
    // LocalVar  12 name i1(I) merged out into k(I)
    // LocalVar  12 name l1(I) merged out into k1(I)
    // LocalVar  15 name abyte17([B) merged out into abyte14([B)
    // LocalVar  16 chged: Name abyte5 Oname obj4 Type [B At 643 2 Range 643 644 Init 643
    // LocalVar  16 name abyte16([B) merged out into abyte5([B)
    // LocalVar  16 name abyte15([B) merged out into abyte5([B)
    // LocalVar  18 name abyte21([B) merged out into abyte19([B)
    private byte[] lnxqtra(byte abyte0[], int i)
        throws SQLException
    {
        byte abyte1[] = null;
        byte abyte3[] = null;
        Object obj = null;
        byte abyte8[] = NUMBER.pi().shareBytes();
        byte abyte9[] = lnxmin(-1L);
        long l = 0L;
        if(i == 3 || i == 4 || i == 5)
        {
            byte abyte4[] = lnxmul(lnxqtwo, abyte8);
            abyte1 = lnxabs(abyte0);
            abyte1 = lnxmod(abyte1, abyte4);
            if(lnxcmp(abyte1, abyte8) > 0)
            {
                abyte1 = lnxsub(abyte1, abyte4);
            }
            if(lnxsgn(abyte0) == -1)
            {
                abyte1 = lnxneg(abyte1);
            }
            abyte3 = lnxmul(abyte1, abyte1);
        } else
        if(i == 9)
        {
            abyte1 = lnxmod(abyte0, lnxqone);
            byte abyte5[] = lnxsub(abyte0, abyte1);
            if((abyte5[0] & 0xff) < 60)
            {
                return NUMBER._makeZero();
            }
            if((abyte5[0] & 0xff) > 195)
            {
                return NUMBER._makePosInf();
            }
            l = lnxsni(abyte5);
            abyte3 = lnxmul(abyte1, abyte1);
        } else
        {
            abyte1 = new byte[abyte0.length];
            System.arraycopy(abyte0, 0, abyte1, 0, abyte0.length);
            abyte3 = lnxmul(abyte1, abyte1);
        }
        byte abyte10[] = null;
        byte abyte11[] = null;
        if(i != 4 && i != 7)
        {
            byte abyte6[] = lnxqone;
            abyte10 = lnxqone;
            abyte11 = NUMBER._makeZero();
            int i1 = 0;
            do
            {
                abyte6 = lnxmul(abyte3, abyte6);
                int j = (i1 + 1) * (i1 + 2);
                i1 += 2;
                abyte6 = lnxqIDiv(abyte6, j);
                abyte11 = lnxadd(abyte11, abyte6);
                abyte6 = lnxmul(abyte3, abyte6);
                j = (i1 + 1) * (i1 + 2);
                i1 += 2;
                abyte6 = lnxqIDiv(abyte6, j);
                abyte10 = lnxadd(abyte10, abyte6);
            } while((abyte6[0] & 0xff) + 20 >= (abyte10[0] & 0xff) && (abyte11[0] & 0xff) != 255);
        }
        byte abyte12[] = null;
        byte abyte13[] = null;
        if(i != 3 && i != 6)
        {
            byte abyte7[] = new byte[abyte1.length];
            System.arraycopy(abyte1, 0, abyte7, 0, abyte1.length);
            abyte12 = new byte[abyte1.length];
            System.arraycopy(abyte1, 0, abyte12, 0, abyte1.length);
            abyte13 = NUMBER._makeZero();
            int j1 = 1;
            do
            {
                abyte7 = lnxmul(abyte3, abyte7);
                int k = (j1 + 1) * (j1 + 2);
                j1 += 2;
                abyte7 = lnxqIDiv(abyte7, k);
                abyte13 = lnxadd(abyte13, abyte7);
                abyte7 = lnxmul(abyte3, abyte7);
                k = (j1 + 1) * (j1 + 2);
                j1 += 2;
                abyte7 = lnxqIDiv(abyte7, k);
                abyte12 = lnxadd(abyte12, abyte7);
            } while(((abyte7[0] & 0xff) != 128 || abyte7.length != 1) && ((abyte7[0] & 0xff) < 128 || (abyte7[0] & 0xff) + 20 >= (abyte12[0] & 0xff)) && ((abyte7[0] & 0xff) >= 128 || (abyte7[0] & 0xff) <= (abyte12[0] & 0xff) + 20) && (abyte13[0] & 0xff) != 255 && (abyte13[0] & 0xff) != 0);
        }
        byte abyte14[] = null;
        byte abyte15[] = null;
        if(i == 3 || i == 4 || i == 5)
        {
            if(i == 3 || i == 5)
            {
                abyte14 = lnxsub(abyte10, abyte11);
                if(lnxcmp(abyte14, lnxqone) > 0)
                {
                    abyte14 = lnxqone;
                } else
                if(lnxcmp(abyte14, abyte9) < 0)
                {
                    abyte14 = abyte9;
                }
            }
            if(i == 3)
            {
                return abyte14;
            }
            abyte15 = lnxsub(abyte12, abyte13);
            if(lnxcmp(abyte15, lnxqone) > 0)
            {
                abyte15 = lnxqone;
            } else
            if(lnxcmp(abyte15, abyte9) < 0)
            {
                abyte15 = abyte9;
            }
            if(i == 4)
            {
                return abyte15;
            } else
            {
                return lnxdiv(abyte15, abyte14);
            }
        }
        if(i == 6)
        {
            return lnxadd(abyte10, abyte11);
        }
        if(i == 7)
        {
            return lnxadd(abyte12, abyte13);
        }
        abyte15 = lnxadd(abyte12, abyte13);
        abyte14 = lnxadd(abyte10, abyte11);
        if(i == 8)
        {
            return lnxdiv(abyte15, abyte14);
        } else
        {
            byte abyte16[] = NUMBER.e().shareBytes();
            byte abyte17[] = lnxadd(abyte14, abyte15);
            byte abyte2[] = lnxpow(abyte16, (int)l);
            abyte17 = lnxmul(abyte17, abyte2);
            return abyte17;
        }
    }

    // Decompiling method: lnxqtri  Signature: ([BI)[B
    // Max stack: 5, #locals: 15, #params: 3
    // Code length: 580 bytes, Code offset: 72650
    // Line Number Table found: 77 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 580 Range 0 579 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 580 Range 0 579 Init 0
    // Parameter  2 added: Name i Type I At 0 580 Range 0 579 Init 0
    // RetValue  15 added: Name <returnValue> Type [B At 0 580 Range 0 579 Init 0 fixed
    // LocalVar   3 added: Name obj Type A At 1 1 Range 1 1 Init 1
    // LocalVar   4 added: Name obj1 Type A At 3 2 Range 3 4 Init 3
    // LocalVar   5 added: Name obj2 Type A At 6 2 Range 6 7 Init 6
    // LocalVar   6 added: Name abyte1 Type [B At 14 533 Range 14 546 Init 14
    // LocalVar   7 added: Name abyte2 Type [B At 25 506 Range 25 530 Init 25
    // LocalVar   8 added: Name abyte3 Type [B At 61 184 Range 61 244 Init 61
    // LocalVar   9 added: Name abyte4 Type [B At 120 14 Range 120 133 Init 120
    // LocalVar   3 added: Name abyte5 Type [B At 152 14 Range 152 165 Init 152
    // LocalVar   4 added: Name abyte6 Type [B At 162 6 Range 162 167 Init 162
    // LocalVar   9 added: Name j Type I At 191 235 Range 191 425 Init 191
    // LocalVar   3 added: Name abyte7 Type [B At 212 351 Range 212 562 Init 212
    // LocalVar  10 added: Name flag Type Z At 225 196 Range 225 420 Init 225
    // LocalVar  13 added: Name byte0 Type B At 229 2 Range 229 230 Init 229
    // LocalVar  14 added: Name byte1 Type B At 233 2 Range 233 234 Init 233
    // LocalVar   4 added: Name abyte8 Type [B At 240 17 Range 240 256 Init 240
    // LocalVar   5 added: Name abyte9 Type [B At 250 26 Range 250 275 Init 250
    // LocalVar   4 added: Name abyte10 Type [B At 260 5 Range 260 264 Init 260
    // LocalVar   4 added: Name abyte11 Type [B At 271 7 Range 271 277 Init 271
    // LocalVar   4 added: Name abyte12 Type [B At 281 133 Range 281 413 Init 281
    // LocalVar  11 added: Name k Type I At 323 64 Range 323 386 Init 323
    // LocalVar  12 added: Name l Type I At 362 34 Range 362 395 Init 362
    // LocalVar  10 chged: Name i1 Oname flag Type I At 403 2 Range 225 420 Init 225
    // LocalVar   3 chged: Name abyte13 Oname obj Type [B At 1 1 Range 1 1 Init 1
    // LocalVar   3 name abyte7([B) merged out into abyte13([B)
    // LocalVar   3 name abyte5([B) merged out into abyte13([B)
    // LocalVar   4 name abyte10([B) merged out into abyte8([B)
    // LocalVar   4 name abyte11([B) merged out into abyte8([B)
    // LocalVar   4 name abyte12([B) merged out into abyte8([B)
    private byte[] lnxqtri(byte abyte0[], int i)
        throws SQLException
    {
        byte abyte1[] = null;
        Object obj = null;
        Object obj1 = null;
        byte abyte5[] = NUMBER.pi().shareBytes();
        byte abyte6[] = lnxdiv(abyte5, lnxqtwo);
        if(i == 2)
        {
            if(NUMBER._isPosInf(abyte0))
            {
                return abyte6;
            }
            if(NUMBER._isNegInf(abyte0))
            {
                return lnxneg(abyte6);
            }
        }
        byte abyte7[] = lnxabs(abyte0);
        if(i == 1 || i == 0)
        {
            if(lnxcmp(abyte7, lnxqone) > 0)
            {
                throw new SQLException(CoreException.getMessage((byte)11));
            }
            if((abyte7[0] & 0xff) <= 183)
            {
                if(i == 1)
                {
                    byte abyte8[] = new byte[abyte0.length];
                    System.arraycopy(abyte0, 0, abyte8, 0, abyte0.length);
                    return abyte8;
                } else
                {
                    return lnxsub(abyte6, abyte0);
                }
            }
            abyte1 = lnxsub(lnxqone, abyte7);
            byte abyte2[] = lnxadd(lnxqone, abyte7);
            abyte7 = lnxdiv(abyte1, abyte2);
            abyte7 = lnxsqr(abyte7);
        }
        int j;
        if((j = lnxcmp(abyte7, lnxqone)) > 0)
        {
            abyte7 = lnxdiv(lnxqone, abyte7);
        }
        abyte1 = new byte[abyte7.length];
        System.arraycopy(abyte7, 0, abyte1, 0, abyte7.length);
        int k = 1;
        byte byte0 = 15;
        byte byte1 = 15;
        do
        {
            byte abyte3[] = lnxtan(abyte1);
            byte abyte4[] = lnxsub(abyte7, abyte3);
            abyte3 = lnxmul(abyte3, abyte3);
            abyte3 = lnxadd(abyte3, lnxqone);
            abyte3 = lnxdiv(abyte4, abyte3);
            int l = (abyte3[0] & 0xff) < 128 ? 62 - (abyte3[0] & 0xff) : (abyte3[0] & 0xff) - 193;
            int i1 = (abyte1[0] & 0xff) < 128 ? 62 - (abyte1[0] & 0xff) : (abyte1[0] & 0xff) - 193;
            if((abyte3[0] & 0xff) == 128 && abyte3.length == 1 || (l & 0xff) + 15 < (i1 & 0xff) || k > 15)
            {
                break;
            }
            abyte1 = lnxadd(abyte1, abyte3);
            k++;
        } while(true);
        if(j > 0)
        {
            abyte1 = lnxsub(abyte6, abyte1);
        }
        if((abyte1[0] & 0xff) < 128)
        {
            abyte1 = NUMBER._makeZero();
        }
        if(lnxcmp(abyte1, abyte6) > 0)
        {
            abyte1 = abyte6;
        }
        if(i == 1 || i == 0)
        {
            abyte1 = lnxmul(abyte1, lnxqtwo);
        }
        switch(i)
        {
        case 1: // '\001'
            if(NUMBER._isPositive(abyte0))
            {
                return lnxsub(abyte6, abyte1);
            } else
            {
                return lnxsub(abyte1, abyte6);
            }

        case 0: // '\0'
            if(NUMBER._isPositive(abyte0))
            {
                return abyte1;
            } else
            {
                return lnxsub(abyte5, abyte1);
            }

        case 2: // '\002'
            if(NUMBER._isPositive(abyte0))
            {
                return abyte1;
            } else
            {
                return lnxneg(abyte1);
            }
        }
        throw new SQLException(CoreException.getMessage((byte)11));
    }

    // Decompiling method: lnxren  Signature: (D)[B
    // Max stack: 5, #locals: 12, #params: 3
    // Code length: 409 bytes, Code offset: 73582
    // Line Number Table found: 58 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 409 Range 0 408 Init 0 fixed
    // Parameter  1 added: Name d Type D At 0 409 Range 0 408 Init 0
    // RetValue  12 added: Name <returnValue> Type [B At 0 409 Range 0 408 Init 0 fixed
    // LocalVar   3 added: Name abyte0 Type [B At 4 388 Range 4 391 Init 4
    // LocalVar   4 added: Name flag Type Z At 6 383 Range 6 388 Init 6
    // LocalVar   6 added: Name flag1 Type Z At 19 386 Range 19 404 Init 19
    // LocalVar  10 added: Name flag2 Type Z At 33 48 Range 33 80 Init 33
    // LocalVar  10 chged: Name i Oname flag2 Type I At 79 2 Range 33 80 Init 33
    // LocalVar   4 chged: Name j Oname flag Type I At 92 3 Range 6 388 Init 6
    // LocalVar  10 added: Name flag Type Z At 105 48 Range 105 152 Init 105
    // LocalVar  10 chged: Name k Oname flag Type I At 151 2 Range 105 152 Init 105
    // LocalVar   5 added: Name flag Type Z At 209 54 Range 209 262 Init 209
    // LocalVar   7 added: Name byte0 Type B At 213 185 Range 213 397 Init 213
    // LocalVar   9 added: Name flag2 Type Z At 216 36 Range 216 251 Init 216
    // LocalVar   8 added: Name byte1 Type B At 221 47 Range 221 267 Init 221
    // LocalVar   9 chged: Name l Oname flag2 Type I At 250 2 Range 216 251 Init 216
    // LocalVar   9 added: Name byte2 Type B At 259 82 Range 259 340 Init 259
    // LocalVar   9 added: Name byte3 Type B At 349 23 Range 349 371 Init 349
    // LocalVar  11 added: Name abyte1 Type [B At 382 21 Range 382 402 Init 382
    // LocalVar   8 chged: Name i1 Oname byte1 Type I At 233 2 Range 221 267 Init 221
    // LocalVar   8 chged: Name byte1 Oname i1 Type B At 229 39 Range 221 267 Init 221
    // LocalVar   9 chged: Name i1 Oname byte2 Type I At 326 3 Range 259 340 Init 259
    // LocalVar   9 chged: Name j1 Oname byte3 Type I At 361 3 Range 349 371 Init 349
    // LocalVar   9 name i1(I) merged out into l(I)
    public byte[] lnxren(double d)
        throws SQLException
    {
        byte abyte0[] = new byte[20];
        int i = 0;
        boolean flag1 = d >= 0.0D;
        d = Math.abs(d);
        if(d < 1.0D)
        {
            for(int l = 0; l < 8; l++)
            {
                if(powerTable[l][2] >= d)
                {
                    i -= (int)powerTable[l][0];
                    d *= powerTable[l][1];
                }
            }

            if(d < 1.0D)
            {
                i--;
                d *= 100D;
            }
        } else
        {
            for(int i1 = 0; i1 < 8; i1++)
            {
                if(powerTable[i1][1] <= d)
                {
                    i += (int)powerTable[i1][0];
                    d *= powerTable[i1][2];
                }
            }

        }
        if(i > 62)
        {
            throw new SQLException(CoreException.getMessage((byte)3));
        }
        if(i < -65)
        {
            throw new SQLException(CoreException.getMessage((byte)2));
        }
        boolean flag = d < 10D;
        byte byte0 = 8;
        int j = 0;
        byte byte1 = (byte)(int)d;
        for(; j < byte0; j++)
        {
            abyte0[j] = byte1;
            d = (d - (double)byte1) * 100D;
            byte1 = (byte)(int)d;
        }

        j = 7;
        if(flag)
        {
            if(byte1 >= 50)
            {
                abyte0[j]++;
            }
        } else
        {
            abyte0[j] = (byte)(((abyte0[j] + 5) / 10) * 10);
        }
        for(; abyte0[j] == 100; abyte0[j]++)
        {
            if(j == 0)
            {
                i++;
                abyte0[j] = 1;
                break;
            }
            abyte0[j] = 0;
            j--;
        }

        for(int k = 7; k != 0 && abyte0[k] == 0; k--)
        {
            byte0--;
        }

        byte abyte1[] = new byte[byte0 + 1];
        abyte1[0] = (byte)i;
        System.arraycopy(abyte0, 0, abyte1, 1, byte0);
        return NUMBER._toLnxFmt(abyte1, flag1);
    }

    // Decompiling method: lnxren  Signature: (F)[B
    // Max stack: 5, #locals: 11, #params: 2
    // Code length: 376 bytes, Code offset: 74267
    // Line Number Table found: 54 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 376 Range 0 375 Init 0 fixed
    // Parameter  1 added: Name f Type F At 0 376 Range 0 375 Init 0
    // RetValue  11 added: Name <returnValue> Type [B At 0 376 Range 0 375 Init 0 fixed
    // LocalVar   2 added: Name abyte0 Type [B At 4 355 Range 4 358 Init 4
    // LocalVar   3 added: Name flag Type Z At 6 350 Range 6 355 Init 6
    // LocalVar   9 added: Name flag1 Type Z At 18 354 Range 18 371 Init 18
    // LocalVar   6 added: Name byte0 Type B At 32 49 Range 32 80 Init 32
    // LocalVar   3 chged: Name i Oname flag Type I At 92 3 Range 6 355 Init 6
    // LocalVar   6 added: Name byte1 Type B At 107 49 Range 107 155 Init 107
    // LocalVar   8 added: Name flag Type Z At 169 60 Range 169 228 Init 169
    // LocalVar   5 added: Name byte2 Type B At 172 193 Range 172 364 Init 172
    // LocalVar   7 added: Name flag2 Type Z At 184 123 Range 184 306 Init 184
    // LocalVar   4 added: Name byte3 Type B At 189 45 Range 189 233 Init 189
    // LocalVar   7 chged: Name j Oname flag2 Type I At 217 2 Range 184 306 Init 184
    // LocalVar   7 added: Name k Type I At 317 23 Range 317 339 Init 317
    // LocalVar  10 added: Name abyte1 Type [B At 350 20 Range 350 369 Init 350
    // LocalVar   6 chged: Name l Oname byte0 Type I At 76 3 Range 32 80 Init 32
    // LocalVar   6 chged: Name i1 Oname byte1 Type I At 151 3 Range 107 155 Init 107
    // LocalVar   4 chged: Name j1 Oname byte3 Type I At 201 2 Range 189 233 Init 189
    // LocalVar   4 chged: Name byte0 Oname j1 Type B At 197 37 Range 189 233 Init 189
    public byte[] lnxren(float f)
    {
        byte abyte0[] = new byte[20];
        int i = 0;
        boolean flag1 = f >= 0.0F;
        f = Math.abs(f);
        if(f < 1.0F)
        {
            for(int j = 3; j < 8; j++)
            {
                if(powerTable[j][2] >= (double)f)
                {
                    i -= (int)powerTable[j][0];
                    f = (float)((double)f * powerTable[j][1]);
                }
            }

            if(f < 1.0F)
            {
                i--;
                f = (float)((double)f * 100D);
            }
        } else
        {
            for(int k = 3; k < 8; k++)
            {
                if(powerTable[k][1] <= (double)f)
                {
                    i += (int)powerTable[k][0];
                    f = (float)((double)f * powerTable[k][2]);
                }
            }

        }
        byte byte1;
        boolean flag;
        if(f >= 10F)
        {
            flag = true;
            byte1 = 4;
        } else
        {
            flag = false;
            byte1 = 5;
        }
        int l = 0;
        byte byte0 = (byte)(int)f;
        for(; l < byte1; l++)
        {
            abyte0[l] = byte0;
            f = (f - (float)byte0) * 100F;
            byte0 = (byte)(int)f;
        }

        l--;
        if(flag)
        {
            if(byte0 >= 50)
            {
                abyte0[l]++;
            }
        } else
        {
            abyte0[l] = (byte)(((abyte0[l] + 5) / 10) * 10);
        }
        for(; abyte0[l] == 100; abyte0[l]++)
        {
            if(l == 0)
            {
                i++;
                abyte0[l] = 1;
                break;
            }
            abyte0[l] = 0;
            l--;
        }

        for(int i1 = byte1 - 1; i1 > 0 && abyte0[i1] == 0; i1--)
        {
            byte1--;
        }

        byte abyte1[] = new byte[byte1 + 1];
        abyte1[0] = (byte)i;
        System.arraycopy(abyte0, 0, abyte1, 1, byte1);
        return NUMBER._toLnxFmt(abyte1, flag1);
    }

    // Decompiling method: lnxrou  Signature: ([BI)[B
    // Max stack: 5, #locals: 16, #params: 3
    // Code length: 795 bytes, Code offset: 74893
    // Line Number Table found: 100 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 795 Range 0 794 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 795 Range 0 794 Init 0
    // Parameter  2 added: Name i Type I At 0 795 Range 0 794 Init 0
    // RetValue  16 added: Name <returnValue> Type [B At 0 795 Range 0 794 Init 0 fixed
    // LocalVar   3 added: Name j Type I At 2 293 Range 2 294 Init 2
    // LocalVar   4 added: Name flag Type Z At 4 769 Range 4 772 Init 4
    // LocalVar   4 chged: Name k Oname flag Type I At 12 2 Range 4 772 Init 4
    // LocalVar  15 added: Name l Type I At 71 131 Range 71 201 Init 71
    // LocalVar   7 added: Name flag Type Z At 78 587 Range 78 664 Init 78
    // LocalVar  11 added: Name i1 Type I At 99 684 Range 99 782 Init 99
    // LocalVar  12 added: Name flag1 Type Z At 112 369 Range 112 480 Init 112
    // LocalVar   8 added: Name flag2 Type Z At 146 620 Range 146 765 Init 146
    // LocalVar   9 added: Name byte0 Type B At 150 472 Range 150 621 Init 150
    // LocalVar  10 added: Name flag3 Type Z At 153 565 Range 153 717 Init 153
    // LocalVar   8 chged: Name byte1 Oname flag2 Type B At 220 546 Range 146 765 Init 146
    // LocalVar  10 chged: Name byte2 Oname flag3 Type B At 226 492 Range 153 717 Init 153
    // LocalVar   6 added: Name abyte1 Type [B At 249 540 Range 249 788 Init 249
    // LocalVar  13 added: Name byte3 Type B At 475 269 Range 475 743 Init 475
    // LocalVar   5 added: Name byte4 Type B At 477 104 Range 477 580 Init 477
    // LocalVar   5 added: Name byte5 Type B At 584 187 Range 584 770 Init 584
    // LocalVar  14 added: Name j1 Type I At 728 63 Range 728 790 Init 728
    // LocalVar   5 name byte5(B) merged out into byte4(B)
    public byte[] lnxrou(byte abyte0[], int i)
        throws SQLException
    {
        int j = abyte0.length;
        int k = 0;
        if(j == 1)
        {
            if(abyte0[k] == -128)
            {
                return NUMBER._makeZero();
            } else
            {
                return NUMBER._makeNegInf();
            }
        }
        if(j == 2 && abyte0[0] == -1 && abyte0[1] == 101)
        {
            return NUMBER._makePosInf();
        }
        int j1 = abyte0[0] >= 0 ? ((int) (abyte0[0])) : 256 + abyte0[0];
        boolean flag;
        byte byte1;
        byte byte2;
        byte byte3;
        int l;
        boolean flag1;
        if(flag = NUMBER._isPositive(abyte0))
        {
            if(i >= 0)
            {
                l = (j1 + (i + 1 >> 1)) - 192;
                flag1 = (i & 0x1) != 0;
            } else
            {
                i = -i;
                l = j1 - (i >> 1) - 192;
                flag1 = (i & 0x1) != 0;
            }
            byte1 = 1;
            byte2 = 100;
            byte3 = 1;
        } else
        {
            if(i >= 0)
            {
                l = (63 + (i + 1 >> 1)) - j1;
                flag1 = (i & 0x1) != 0;
            } else
            {
                i = -i;
                l = 63 - (i >> 1) - j1;
                flag1 = (i & 0x1) != 0;
            }
            byte1 = 101;
            byte2 = 2;
            byte3 = -1;
            j -= abyte0[j - 1] != 102 ? 0 : 1;
        }
        byte abyte1[] = new byte[j];
        System.arraycopy(abyte0, 0, abyte1, 0, j);
        if(l > j - 1 || l == j - 1 && (!flag1 || LnxqFirstDigit[abyte0[l]] == 1))
        {
            return _setLength(abyte0, j);
        }
        if(l < 0 || l == 0 && (flag1 || (flag ? abyte0[1] < 51 || false : abyte0[1] > 51 || false)) || l == 1 && flag1 && (flag ? abyte0[1] < 6 || false : abyte0[1] > 96 || false))
        {
            return NUMBER._makeZero();
        }
        if(l == 0)
        {
            if(flag ? abyte0[k] == -1 || false : abyte0[k] == 0 || false)
            {
                if(flag)
                {
                    return NUMBER._makePosInf();
                } else
                {
                    return NUMBER._makeNegInf();
                }
            } else
            {
                abyte1[0] = (byte)(abyte0[k] + byte3);
                abyte1[1] = (byte)(byte1 + byte3);
                return _setLength(abyte1, 2);
            }
        }
        byte byte4;
        byte byte0 = byte4 = (byte)l;
        if(flag1)
        {
            abyte1[byte4] = flag ? LnxqRound_P[abyte0[byte0]] : LnxqRound_N[abyte0[byte0]];
        } else
        if(flag ? abyte0[byte0 + 1] > 50 || false : abyte0[byte0 + 1] < 52 || false)
        {
            abyte1[byte4] = (byte)(abyte0[byte0] + byte3);
        } else
        {
            abyte1[byte4] = abyte0[byte0];
        }
        byte0--;
        int i1;
        if(abyte1[byte4] == byte2 + byte3)
        {
            for(; byte0 > k && abyte0[byte0] == byte2; byte0--) { }
            if(byte0 == k)
            {
                if(flag ? abyte0[k] == -1 || false : abyte0[k] == 0 || false)
                {
                    if(flag)
                    {
                        return NUMBER._makePosInf();
                    } else
                    {
                        return NUMBER._makeNegInf();
                    }
                } else
                {
                    abyte1[0] = (byte)(abyte0[k] + byte3);
                    abyte1[1] = (byte)(byte1 + byte3);
                    return _setLength(abyte1, 2);
                }
            }
            abyte1[byte0 - k] = (byte)(abyte0[byte0] + byte3);
            i1 = (byte0 - k) + 1;
            byte0--;
        } else
        if(abyte1[byte4] == byte1)
        {
            for(; abyte0[byte0] == byte1; byte0--) { }
            i1 = (byte0 - k) + 1;
        } else
        {
            i1 = l + 1;
        }
        return _setLength(abyte1, i1);
    }

    // Decompiling method: lnxsca  Signature: ([BII[Z)[B
    // Max stack: 5, #locals: 11, #params: 5
    // Code length: 286 bytes, Code offset: 76132
    // Line Number Table found: 28 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 286 Range 0 285 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 286 Range 0 285 Init 0
    // Parameter  2 added: Name i Type I At 0 286 Range 0 285 Init 0
    // Parameter  3 added: Name j Type I At 0 286 Range 0 285 Init 0
    // Parameter  4 added: Name aflag Type [Z At 0 286 Range 0 285 Init 0
    // RetValue  11 added: Name <returnValue> Type [B At 0 286 Range 0 285 Init 0 fixed
    // LocalVar   8 added: Name k Type I At 2 86 Range 2 87 Init 2
    // LocalVar   5 added: Name byte0 Type B At 28 220 Range 28 247 Init 28
    // LocalVar   6 added: Name byte1 Type B At 33 220 Range 33 252 Init 33
    // LocalVar   7 added: Name byte2 Type B At 41 53 Range 41 93 Init 41
    // LocalVar   9 added: Name abyte1 Type [B At 117 104 Range 117 220 Init 117
    // LocalVar   9 added: Name l Type I At 224 15 Range 224 238 Init 224
    // LocalVar  10 added: Name abyte2 Type [B At 230 46 Range 230 275 Init 230
    public byte[] lnxsca(byte abyte0[], int i, int j, boolean aflag[])
        throws SQLException
    {
        int k = abyte0.length;
        if(k != 1)
        {
            byte byte0;
            byte byte1;
            byte byte2;
            if(NUMBER._isPositive(abyte0))
            {
                byte0 = (byte)((abyte0[0] & 0xffffff7f) - 65);
                byte1 = abyte0[1];
                byte2 = abyte0[k - 1];
            } else
            {
                k--;
                byte0 = (byte)((~abyte0[0] & 0xffffff7f) - 65);
                byte1 = LnxqNegate[abyte0[1]];
                byte2 = LnxqNegate[abyte0[k - 1]];
            }
            if(2 * (k - byte0) - (byte2 % 10 != 1 ? 0 : 1) > j)
            {
                byte abyte1[] = lnxrou(abyte0, j);
                if(NUMBER._isPositive(abyte1))
                {
                    byte0 = (byte)((abyte1[0] & 0xffffff7f) - 65);
                    byte1 = abyte1.length == 1 ? 1 : abyte1[1];
                } else
                {
                    byte0 = (byte)((~abyte1[0] & 0xffffff7f) - 65);
                    byte1 = LnxqNegate[abyte1[1]];
                }
                aflag[0] = 2 * (byte0 + 1) - (byte1 >= 11 ? 0 : 1) > i;
                return abyte1;
            } else
            {
                int l = abyte0.length;
                byte abyte2[] = new byte[l];
                System.arraycopy(abyte0, 0, abyte2, 0, l);
                aflag[0] = 2 * (byte0 + 1) - (byte1 >= 11 ? 0 : 1) > i;
                return abyte2;
            }
        } else
        {
            aflag[0] = false;
            return NUMBER._makeZero();
        }
    }

    // Decompiling method: lnxsgn  Signature: ([B)I
    // Max stack: 1, #locals: 2, #params: 2
    // Code length: 20 bytes, Code offset: 76574
    // Line Number Table found: 4 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 20 Range 0 19 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 20 Range 0 19 Init 0
    // RetValue   2 added: Name <returnValue> Type I At 0 20 Range 0 19 Init 0 fixed
    private int lnxsgn(byte abyte0[])
    {
        if(NUMBER._isZero(abyte0))
        {
            return 0;
        }
        return !NUMBER._isPositive(abyte0) ? -1 : 1;
    }

    // Decompiling method: lnxshift  Signature: ([BI)[B
    // Max stack: 7, #locals: 21, #params: 3
    // Code length: 783 bytes, Code offset: 76644
    // Line Number Table found: 91 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 783 Range 0 782 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 783 Range 0 782 Init 0
    // Parameter  2 added: Name i Type I At 0 783 Range 0 782 Init 0
    // RetValue  21 added: Name <returnValue> Type [B At 0 783 Range 0 782 Init 0 fixed
    // LocalVar   3 added: Name abyte1 Type [B At 1 644 Range 1 644 Init 1
    // LocalVar   4 added: Name j Type I At 4 179 Range 4 182 Init 4
    // LocalVar   6 added: Name abyte2 Type [B At 10 756 Range 10 765 Init 10
    // LocalVar   7 added: Name k Type I At 15 2 Range 15 16 Init 15
    // LocalVar   8 added: Name flag Type Z At 18 2 Range 18 19 Init 18
    // LocalVar  11 added: Name abyte3 Type [B At 24 2 Range 24 25 Init 24
    // LocalVar  17 added: Name flag1 Type Z At 27 2 Range 27 28 Init 27
    // LocalVar  18 added: Name flag2 Type Z At 36 49 Range 36 84 Init 36
    // LocalVar  18 chged: Name l Oname flag2 Type I At 83 2 Range 36 84 Init 36
    // LocalVar   5 added: Name abyte4 Type [B At 107 29 Range 107 135 Init 107
    // LocalVar  18 added: Name flag2 Type Z At 110 19 Range 110 128 Init 110
    // LocalVar  18 chged: Name i1 Oname flag2 Type I At 127 2 Range 110 128 Init 110
    // LocalVar  12 added: Name flag2 Type Z At 151 580 Range 151 730 Init 151
    // LocalVar  14 added: Name j1 Type I At 179 448 Range 179 626 Init 179
    // LocalVar  15 added: Name k1 Type I At 183 594 Range 183 776 Init 183
    // LocalVar   9 added: Name abyte5 Type [[B At 213 350 Range 213 562 Init 213
    // LocalVar  10 added: Name abyte6 Type [[B At 218 343 Range 218 560 Init 218
    // LocalVar  16 added: Name byte0 Type B At 222 367 Range 222 588 Init 222
    // LocalVar   8 added: Name l1 Type I At 279 124 Range 279 402 Init 279
    // LocalVar  17 added: Name i2 Type I At 285 101 Range 285 385 Init 285
    // LocalVar  13 added: Name flag3 Type Z At 314 99 Range 314 412 Init 314
    // LocalVar  19 added: Name byte1 Type B At 427 34 Range 427 460 Init 427
    // LocalVar  20 added: Name byte2 Type B At 439 33 Range 439 471 Init 439
    // LocalVar  17 added: Name byte3 Type B At 443 25 Range 443 467 Init 443
    // LocalVar   8 added: Name flag4 Type Z At 503 63 Range 503 565 Init 503
    // LocalVar  17 added: Name flag5 Type Z At 506 53 Range 506 558 Init 506
    // LocalVar  17 chged: Name j2 Oname flag5 Type I At 546 2 Range 506 558 Init 506
    // LocalVar   8 chged: Name k2 Oname flag4 Type I At 564 2 Range 503 565 Init 503
    // LocalVar  18 added: Name flag4 Type Z At 635 19 Range 635 653 Init 635
    // LocalVar  18 chged: Name l2 Oname flag4 Type I At 652 2 Range 635 653 Init 635
    // LocalVar   5 added: Name abyte7 Type [B At 675 28 Range 675 702 Init 675
    // LocalVar   5 added: Name abyte8 Type [B At 715 10 Range 715 724 Init 715
    // LocalVar   5 added: Name abyte9 Type [B At 752 30 Range 752 781 Init 752
    // LocalVar  18 added: Name flag4 Type Z At 755 20 Range 755 774 Init 755
    // LocalVar  18 chged: Name i3 Oname flag4 Type I At 773 2 Range 755 774 Init 755
    // LocalVar  17 chged: Name j3 Oname byte3 Type I At 448 3 Range 443 467 Init 443
    public byte[] lnxshift(byte abyte0[], int i)
        throws SQLException
    {
        byte abyte1[] = abyte0;
        int j = abyte1.length;
        byte abyte6[] = new byte[22];
        int k = abyte6.length;
        boolean flag = false;
        byte abyte9[] = new byte[22];
        boolean flag3 = false;
        int k2;
        if(j == 1)
        {
            k2 = 0;
        } else
        {
            k2 = 1;
        }
        if((abyte1[0] & 0xff) == 128 && j == 1 || j == 2 && (abyte1[0] & 0xff) == 255 && abyte1[k2] == 101 || j == 1 && abyte1[0] == 0)
        {
            byte abyte2[] = new byte[j];
            for(int l2 = 0; l2 < j; l2++)
            {
                abyte2[l2] = abyte1[l2];
            }

            return abyte2;
        }
        boolean flag1 = abyte1[0] >> 7 == 0;
        int j1 = flag1 ? 255 - abyte1[0] & 0xff : abyte1[0] & 0xff;
        int k1 = j;
        if((i & 0x1) > 0)
        {
            byte abyte7[][];
            byte abyte8[][];
            byte byte0;
            if(flag1)
            {
                if(abyte1[k1 - 1] == 102)
                {
                    k1--;
                }
                abyte7 = LnxqComponents_N;
                abyte8 = LnxqDigit_N;
                byte0 = 101;
            } else
            {
                abyte7 = LnxqComponents_P;
                abyte8 = LnxqDigit_P;
                byte0 = 1;
            }
            if(abyte7[abyte1[1]][0] != 0)
            {
                j1 = i < 0 ? j1 - -i / 2 : j1 + (i / 2 + 1);
                int l = k1 - 2;
                int l1 = k1 - 1;
                boolean flag2;
                if(k1 > 20)
                {
                    flag2 = abyte7[abyte1[l + 1]][1] >= 5;
                } else
                {
                    abyte6[l1 + 1] = abyte8[abyte7[abyte1[l + 1]][1]][0];
                    k1++;
                    flag2 = false;
                }
                while(l > 0) 
                {
                    abyte6[l1] = abyte8[abyte7[abyte1[l]][1]][abyte7[abyte1[l + 1]][0]];
                    l--;
                    l1--;
                }
                abyte6[1] = abyte8[0][abyte7[abyte1[l + 1]][0]];
                if(flag2)
                {
                    byte byte1 = flag1 ? ((byte) (2)) : 100;
                    byte byte2 = flag1 ? ((byte) (-1)) : 1;
                    int i2;
                    for(i2 = 20; abyte6[i2] == byte1;)
                    {
                        i2--;
                        k1--;
                    }

                    abyte6[i2] += byte2;
                }
            } else
            {
                j1 = i < 0 ? j1 - (-i / 2 + 1) : j1 + i / 2;
                int i1 = 1;
                int j2;
                for(j2 = 1; j2 < k1 - 1; j2++)
                {
                    abyte6[j2] = abyte8[abyte7[abyte1[i1]][1]][abyte7[abyte1[i1 + 1]][0]];
                    i1++;
                }

                abyte6[j2] = abyte8[abyte7[abyte1[i1]][1]][0];
            }
            for(; abyte6[k1 - 1] == byte0; k1--) { }
            if(flag1)
            {
                k1++;
                abyte6[k1 - 1] = 102;
            }
        } else
        {
            j1 = i < 0 ? j1 - -i / 2 : j1 + i / 2;
            for(int i3 = 1; i3 < k1; i3++)
            {
                abyte6[i3] = abyte1[i3];
            }

        }
        if(j1 > 255)
        {
            byte abyte3[];
            if(flag1)
            {
                abyte3 = new byte[1];
                abyte3[0] = 0;
            } else
            {
                abyte3 = new byte[2];
                abyte3[0] = -1;
                abyte3[1] = 101;
            }
            return abyte3;
        }
        if(j1 < 128)
        {
            byte abyte4[] = new byte[1];
            abyte4[0] = -128;
            return abyte4;
        }
        abyte6[0] = flag1 ? (byte)(255 - j1) : (byte)j1;
        byte abyte5[] = new byte[k1];
        for(int j3 = 0; j3 < k1; j3++)
        {
            abyte5[j3] = abyte6[j3];
        }

        return abyte5;
    }

    // Decompiling method: lnxsin  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 77835
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxsin(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 4);
    }

    // Decompiling method: lnxsnh  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 8 bytes, Code offset: 77890
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 8 Range 0 7 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 8 Range 0 7 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 8 Range 0 7 Init 0 fixed
    public byte[] lnxsnh(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 7);
    }

    // Decompiling method: lnxsni  Signature: ([B)J
    // Max stack: 5, #locals: 10, #params: 2
    // Code length: 111 bytes, Code offset: 77946
    // Line Number Table found: 12 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 111 Range 0 110 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 111 Range 0 110 Init 0
    // RetValue  10 added: Name <returnValue> Type J At 0 111 Range 0 110 Init 0 fixed
    // LocalVar   2 added: Name l Type J At 1 108 Range 1 108 Init 1
    // LocalVar   4 added: Name abyte1 Type [B At 6 49 Range 6 54 Init 6
    // LocalVar   5 added: Name byte0 Type B At 12 63 Range 12 74 Init 12
    // LocalVar   6 added: Name byte1 Type B At 20 57 Range 20 76 Init 20
    // LocalVar   7 added: Name i Type I At 40 30 Range 40 69 Init 40
    // LocalVar   8 added: Name flag Type Z At 43 25 Range 43 67 Init 43
    // LocalVar   8 chged: Name j Oname flag Type I At 66 2 Range 43 67 Init 43
    // LocalVar   9 added: Name k Type I At 78 16 Range 78 93 Init 78
    public long lnxsni(byte abyte0[])
        throws SQLException
    {
        long l = 0L;
        byte abyte1[] = NUMBER._fromLnxFmt(abyte0);
        byte byte0 = abyte1[0];
        byte byte1 = (byte)(abyte1.length - 1);
        int i = byte1 <= byte0 + 1 ? ((int) (byte1)) : byte0 + 1;
        for(int j = 0; j < i; j++)
        {
            l = l * 100L + (long)abyte1[j + 1];
        }

        for(int k = byte0 - byte1; k >= 0; k--)
        {
            l *= 100L;
        }

        return NUMBER._isPositive(abyte0) ? l : -l;
    }

    // Decompiling method: lnxsqr  Signature: ([B)[B
    // Max stack: 6, #locals: 19, #params: 2
    // Code length: 797 bytes, Code offset: 78149
    // Line Number Table found: 115 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 797 Range 0 796 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 797 Range 0 796 Init 0
    // RetValue  19 added: Name <returnValue> Type [B At 0 797 Range 0 796 Init 0 fixed
    // LocalVar   2 added: Name i Type I At 2 80 Range 2 81 Init 2
    // LocalVar   3 added: Name ai Type [I At 7 462 Range 7 468 Init 7
    // LocalVar   4 added: Name ai1 Type [I At 12 765 Range 12 776 Init 12
    // LocalVar  17 added: Name j Type I At 58 530 Range 58 587 Init 58
    // LocalVar  18 added: Name flag Type Z At 61 20 Range 61 80 Init 61
    // LocalVar  18 chged: Name k Oname flag Type I At 79 2 Range 61 80 Init 61
    // LocalVar  13 added: Name flag Type Z At 86 407 Range 86 492 Init 86
    // LocalVar  13 chged: Name l Oname flag Type I At 88 2 Range 86 492 Init 86
    // LocalVar  14 added: Name i1 Type I At 95 400 Range 95 494 Init 95
    // LocalVar   7 added: Name j1 Type I At 142 83 Range 142 224 Init 142
    // LocalVar   6 added: Name k1 Type I At 190 102 Range 190 291 Init 190
    // LocalVar   7 added: Name l1 Type I At 233 4 Range 233 236 Init 233
    // LocalVar   7 added: Name i2 Type I At 247 4 Range 247 250 Init 247
    // LocalVar   7 added: Name j2 Type I At 259 4 Range 259 262 Init 259
    // LocalVar   7 added: Name k2 Type I At 273 4 Range 273 276 Init 273
    // LocalVar   7 added: Name l2 Type I At 285 25 Range 285 309 Init 285
    // LocalVar   6 added: Name i3 Type I At 294 39 Range 294 332 Init 294
    // LocalVar   9 added: Name byte0 Type B At 297 88 Range 297 384 Init 297
    // LocalVar  10 added: Name j3 Type I At 303 469 Range 303 771 Init 303
    // LocalVar  11 added: Name k3 Type I At 500 291 Range 500 790 Init 500
    // LocalVar  17 added: Name l3 Type I At 599 155 Range 599 753 Init 599
    // LocalVar  12 added: Name i4 Type I At 647 98 Range 647 744 Init 647
    // LocalVar   5 added: Name abyte1 Type [B At 747 49 Range 747 795 Init 747
    // LocalVar  18 added: Name j4 Type I At 761 28 Range 761 788 Init 761
    // LocalVar   7 added: Name k4 Type I At 318 11 Range 318 328 Init 318
    // LocalVar   8 added: Name l4 Type I At 325 113 Range 325 437 Init 325
    // LocalVar   7 name k4(I) merged out into l2(I)
    // LocalVar  11 added: Name k4 Type I At 370 49 Range 370 418 Init 370
    // LocalVar  15 added: Name i5 Type I At 381 51 Range 381 431 Init 381
    // LocalVar  16 added: Name j5 Type I At 387 30 Range 387 416 Init 387
    // LocalVar  15 added: Name k5 Type I At 453 24 Range 453 476 Init 453
    // LocalVar   6 name i3(I) merged out into k1(I)
    // LocalVar   7 name l1(I) merged out into j1(I)
    // LocalVar   7 name i2(I) merged out into j1(I)
    // LocalVar   7 name j2(I) merged out into j1(I)
    // LocalVar   7 name k2(I) merged out into j1(I)
    // LocalVar   7 name l2(I) merged out into j1(I)
    // LocalVar  17 name l3(I) merged out into j(I)
    public byte[] lnxsqr(byte abyte0[])
        throws SQLException
    {
        int i = abyte0.length;
        int ai[] = new int[29];
        int ai1[] = new int[29];
        if(!NUMBER._isPositive(abyte0))
        {
            return NUMBER._makeNegInf();
        }
        if(NUMBER._isPosInf(abyte0))
        {
            return NUMBER._makePosInf();
        }
        if(NUMBER._isZero(abyte0))
        {
            return NUMBER._makeZero();
        }
        int j3 = (abyte0[0] & 0xff) - 193;
        for(int k3 = 1; k3 < i; k3++)
        {
            ai[k3] = abyte0[k3] - 1;
        }

        int i2 = 1;
        int j2 = i2 + 20 + 3;
        int k;
        if((j3 + 128 & 0x1) != 0)
        {
            k = ((ai[i2] * 100 + ai[i2 + 1]) * 100 + ai[i2 + 2]) * 100 + ai[i2 + 3];
            i2 += 3;
        } else
        {
            k = (ai[i2] * 100 + ai[i2 + 1]) * 100 + ai[i2 + 2];
            i2 += 2;
        }
        int j = (int)(Math.sqrt(k) * 100D);
        ai1[1] = j / 10000;
        ai1[2] = (j / 100) % 100;
        ai1[3] = j % 100;
        k -= ai1[1] * j;
        k = k * 100 + ai[i2 + 1];
        k -= ai1[2] * j;
        k = k * 100 + ai[i2 + 2];
        k -= ai1[3] * j;
        i2 += 3;
        j *= 2;
        byte byte0 = 3;
        int i1;
        for(i1 = byte0 + 1; i2 < j2; i1++)
        {
            k = k * 100 + ai[i2];
            int l = k / j;
            k -= l * j;
            ai1[i1] = l;
            int j1 = byte0 + (j2 - i2) >= i1 ? i1 : byte0 + (j2 - i2);
            if(l != 0)
            {
                int k2 = i2 + 1;
                for(int i3 = byte0 + 1; i3 < j1; i3++)
                {
                    ai[k2] -= 2 * l * ai1[i3];
                    k2++;
                }

                if(k2 < j2)
                {
                    ai[k2] -= l * l;
                }
            } else
            if(k == 0)
            {
                int l2;
                for(l2 = i2 + 1; l2 < j2 && ai[l2] == 0; l2++) { }
                if(l2 == j2)
                {
                    break;
                }
            }
            i2++;
        }

        int k1 = i1;
        i1--;
        ai1[0] = 0;
        for(; i1 > 0; i1--)
        {
            while(ai1[i1] > 99) 
            {
                ai1[i1] -= 100;
                ai1[i1 - 1]++;
            }
            for(; ai1[i1] < 0; ai1[i1 - 1]--)
            {
                ai1[i1] += 100;
            }

        }

        j3 = (j3 - (j3 + 128 & 0x1)) / 2 + 1;
        while(ai1[i1] == 0) 
        {
            i1++;
            if(--j3 < -65)
            {
                return NUMBER._makeZero();
            }
        }
        do
        {
            k1--;
        } while(ai1[k1] == 0);
        int l1 = (k1 - i1) + 2;
        if(l1 > 21)
        {
            k1 = i1 + 20;
            if(ai1[k1] >= 50)
            {
                do
                {
                    k1--;
                } while(ai1[k1] == 99);
                ai1[k1]++;
            } else
            {
                do
                {
                    k1--;
                } while(ai1[k1] == 0);
            }
            if(k1 < i1)
            {
                i1 = k1;
                if(++j3 > 62)
                {
                    return NUMBER._makePosInf();
                }
            }
            l1 = (k1 - i1) + 2;
        }
        byte abyte1[] = new byte[l1];
        abyte1[0] = (byte)(j3 - 63);
        for(int l3 = i1; l3 <= k1; l3++)
        {
            abyte1[l3 - (i1 - 1)] = (byte)(ai1[l3] + 1);
        }

        return abyte1;
    }

    // Decompiling method: lnxsub  Signature: ([B[B)[B
    // Max stack: 4, #locals: 3, #params: 3
    // Code length: 11 bytes, Code offset: 79450
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 11 Range 0 10 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 11 Range 0 10 Init 0
    // Parameter  2 added: Name abyte1 Type [B At 0 11 Range 0 10 Init 0
    // RetValue   3 added: Name <returnValue> Type [B At 0 11 Range 0 10 Init 0 fixed
    public byte[] lnxsub(byte abyte0[], byte abyte1[])
        throws SQLException
    {
        return lnxadd(abyte0, lnxneg(abyte1));
    }

    // Decompiling method: lnxtan  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 7 bytes, Code offset: 79509
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 7 Range 0 6 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 7 Range 0 6 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 7 Range 0 6 Init 0 fixed
    public byte[] lnxtan(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 5);
    }

    // Decompiling method: lnxtnh  Signature: ([B)[B
    // Max stack: 3, #locals: 2, #params: 2
    // Code length: 8 bytes, Code offset: 79564
    // Line Number Table found: 1 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 8 Range 0 7 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 8 Range 0 7 Init 0
    // RetValue   2 added: Name <returnValue> Type [B At 0 8 Range 0 7 Init 0 fixed
    public byte[] lnxtnh(byte abyte0[])
        throws SQLException
    {
        return lnxqtra(abyte0, 8);
    }

    // Decompiling method: lnxtru  Signature: ([BI)[B
    // Max stack: 5, #locals: 13, #params: 3
    // Code length: 439 bytes, Code offset: 79620
    // Line Number Table found: 53 entries
    // Parameter  0 added: Name this Type Loracle/sql/LnxLibThin; At 0 439 Range 0 438 Init 0 fixed
    // Parameter  1 added: Name abyte0 Type [B At 0 439 Range 0 438 Init 0
    // Parameter  2 added: Name i Type I At 0 439 Range 0 438 Init 0
    // RetValue  13 added: Name <returnValue> Type [B At 0 439 Range 0 438 Init 0 fixed
    // LocalVar  10 added: Name j Type I At 2 268 Range 2 269 Init 2
    // LocalVar  12 added: Name k Type I At 56 127 Range 56 182 Init 56
    // LocalVar   6 added: Name flag Type Z At 63 278 Range 63 340 Init 63
    // LocalVar   7 added: Name l Type I At 84 344 Range 84 427 Init 84
    // LocalVar   8 added: Name flag1 Type Z At 98 238 Range 98 335 Init 98
    // LocalVar   9 added: Name flag2 Type Z At 133 281 Range 133 413 Init 133
    // LocalVar   9 chged: Name byte0 Oname flag2 Type B At 202 212 Range 133 413 Init 133
    // LocalVar   3 added: Name abyte1 Type [B At 222 211 Range 222 432 Init 222
    // LocalVar   5 added: Name byte1 Type B At 330 54 Range 330 383 Init 330
    // LocalVar   4 added: Name byte2 Type B At 332 60 Range 332 391 Init 332
    // LocalVar   5 added: Name byte3 Type B At 387 32 Range 387 418 Init 387
    // LocalVar  11 added: Name i1 Type I At 421 14 Range 421 434 Init 421
    // LocalVar   5 name byte3(B) merged out into byte1(B)
    public byte[] lnxtru(byte abyte0[], int i)
        throws SQLException
    {
        int k = abyte0.length;
        if(NUMBER._isZero(abyte0))
        {
            return NUMBER._makeZero();
        }
        if(NUMBER._isNegInf(abyte0))
        {
            return NUMBER._makeNegInf();
        }
        if(NUMBER._isPosInf(abyte0))
        {
            return NUMBER._makePosInf();
        }
        int i1 = abyte0[0] >= 0 ? ((int) (abyte0[0])) : 256 + abyte0[0];
        boolean flag;
        int j;
        boolean flag1;
        byte byte2;
        if(flag = NUMBER._isPositive(abyte0))
        {
            if(i >= 0)
            {
                j = (i1 + (i + 1 >> 1)) - 192;
                flag1 = (i & 0x1) == 1;
            } else
            {
                i = -i;
                j = i1 - (i >> 1) - 192;
                flag1 = (i & 0x1) == 1;
            }
            byte2 = 1;
        } else
        {
            if(i >= 0)
            {
                j = (63 + (i + 1 >> 1)) - i1;
                flag1 = (i & 0x1) == 1;
            } else
            {
                i = -i;
                j = 63 - (i >> 1) - i1;
                flag1 = (i & 0x1) == 1;
            }
            byte2 = 101;
            if(abyte0[k - 1] == 102)
            {
                k--;
            }
        }
        byte abyte1[] = new byte[k];
        System.arraycopy(abyte0, 0, abyte1, 0, k);
        if(j > k - 1 || j == k - 1 && (flag1 || LnxqFirstDigit[abyte0[j]] == 1))
        {
            return _setLength(abyte0, k);
        }
        if(j <= 0 || j == 1 && flag1 && (flag ? abyte0[1] < 11 || false : abyte0[1] > 91 || false))
        {
            return NUMBER._makeZero();
        }
        byte byte1;
        byte byte0 = byte1 = (byte)j;
        if(flag1)
        {
            if(flag)
            {
                abyte1[byte0] = LnxqTruncate_P[abyte0[byte1]];
            } else
            {
                abyte1[byte0] = LnxqTruncate_N[abyte0[byte1]];
            }
        } else
        {
            abyte1[byte0] = abyte0[byte1];
        }
        byte1--;
        int l;
        if(abyte1[byte0] == byte2)
        {
            for(; abyte0[byte1] == byte2; byte1--) { }
            l = byte1 + 1;
        } else
        {
            l = j + 1;
        }
        return _setLength(abyte1, l);
    }

    // Decompiling method: <clinit>  Signature: ()V
    // Max stack: 8, #locals: 0, #params: 0
    // Code length: 21788 bytes, Code offset: 6936
    // Line Number Table found: 3207 entries
    // RetValue   0 added: Name <returnValue> Type V At 0 21788 Range 0 21787 Init 0 fixed
    static 
    {
        /* lnxqone = (new byte[] {
            -63, 2
        }); */
        /* lnxqtwo = (new byte[] {
            -63, 3
        }); */
        /* LnxqFirstDigit = (new byte[] {
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 
            0, 1
        }); */
        /* LnxqNegate = (new byte[] {
            0, 101, 100, 99, 98, 97, 96, 95, 94, 93, 
            92, 91, 90, 89, 88, 87, 86, 85, 84, 83, 
            82, 81, 80, 79, 78, 77, 76, 75, 74, 73, 
            72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 
            62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 
            52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 
            42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 
            32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 
            22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 
            12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 
            2, 1
        }); */
        /* LnxqTruncate_P = (new byte[] {
            0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
            1, 11, 11, 11, 11, 11, 11, 11, 11, 11, 
            11, 21, 21, 21, 21, 21, 21, 21, 21, 21, 
            21, 31, 31, 31, 31, 31, 31, 31, 31, 31, 
            31, 41, 41, 41, 41, 41, 41, 41, 41, 41, 
            41, 51, 51, 51, 51, 51, 51, 51, 51, 51, 
            51, 61, 61, 61, 61, 61, 61, 61, 61, 61, 
            61, 71, 71, 71, 71, 71, 71, 71, 71, 71, 
            71, 81, 81, 81, 81, 81, 81, 81, 81, 81, 
            81, 91, 91, 91, 91, 91, 91, 91, 91, 91, 
            91
        }); */
        /* LnxqTruncate_N = (new byte[] {
            0, 0, 11, 11, 11, 11, 11, 11, 11, 11, 
            11, 11, 21, 21, 21, 21, 21, 21, 21, 21, 
            21, 21, 31, 31, 31, 31, 31, 31, 31, 31, 
            31, 31, 41, 41, 41, 41, 41, 41, 41, 41, 
            41, 41, 51, 51, 51, 51, 51, 51, 51, 51, 
            51, 51, 61, 61, 61, 61, 61, 61, 61, 61, 
            61, 61, 71, 71, 71, 71, 71, 71, 71, 71, 
            71, 71, 81, 81, 81, 81, 81, 81, 81, 81, 
            81, 81, 91, 91, 91, 91, 91, 91, 91, 91, 
            91, 91, 101, 101, 101, 101, 101, 101, 101, 101, 
            101, 101
        }); */
        /* LnxqRound_P = (new byte[] {
            0, 1, 1, 1, 1, 1, 11, 11, 11, 11, 
            11, 11, 11, 11, 11, 11, 21, 21, 21, 21, 
            21, 21, 21, 21, 21, 21, 31, 31, 31, 31, 
            31, 31, 31, 31, 31, 31, 41, 41, 41, 41, 
            41, 41, 41, 41, 41, 41, 51, 51, 51, 51, 
            51, 51, 51, 51, 51, 51, 61, 61, 61, 61, 
            61, 61, 61, 61, 61, 61, 71, 71, 71, 71, 
            71, 71, 71, 71, 71, 71, 81, 81, 81, 81, 
            81, 81, 81, 81, 81, 81, 91, 91, 91, 91, 
            91, 91, 91, 91, 91, 91, 101, 101, 101, 101, 
            101
        }); */
        /* LnxqRound_N = (new byte[] {
            0, 0, 1, 1, 1, 1, 1, 11, 11, 11, 
            11, 11, 11, 11, 11, 11, 11, 21, 21, 21, 
            21, 21, 21, 21, 21, 21, 21, 31, 31, 31, 
            31, 31, 31, 31, 31, 31, 31, 41, 41, 41, 
            41, 41, 41, 41, 41, 41, 41, 51, 51, 51, 
            51, 51, 51, 51, 51, 51, 51, 61, 61, 61, 
            61, 61, 61, 61, 61, 61, 61, 71, 71, 71, 
            71, 71, 71, 71, 71, 71, 71, 81, 81, 81, 
            81, 81, 81, 81, 81, 81, 81, 91, 91, 91, 
            91, 91, 91, 91, 91, 91, 91, 101, 101, 101, 
            101, 101
        }); */
        /* LnxqComponents_P = (new byte[][] {
            new byte[2], new byte[2], new byte[] {
                0, 1
            }, new byte[] {
                0, 2
            }, new byte[] {
                0, 3
            }, new byte[] {
                0, 4
            }, new byte[] {
                0, 5
            }, new byte[] {
                0, 6
            }, new byte[] {
                0, 7
            }, new byte[] {
                0, 8
            }, 
            new byte[] {
                0, 9
            }, new byte[] {
                1, 0
            }, new byte[] {
                1, 1
            }, new byte[] {
                1, 2
            }, new byte[] {
                1, 3
            }, new byte[] {
                1, 4
            }, new byte[] {
                1, 5
            }, new byte[] {
                1, 6
            }, new byte[] {
                1, 7
            }, new byte[] {
                1, 8
            }, 
            new byte[] {
                1, 9
            }, new byte[] {
                2, 0
            }, new byte[] {
                2, 1
            }, new byte[] {
                2, 2
            }, new byte[] {
                2, 3
            }, new byte[] {
                2, 4
            }, new byte[] {
                2, 5
            }, new byte[] {
                2, 6
            }, new byte[] {
                2, 7
            }, new byte[] {
                2, 8
            }, 
            new byte[] {
                2, 9
            }, new byte[] {
                3, 0
            }, new byte[] {
                3, 1
            }, new byte[] {
                3, 2
            }, new byte[] {
                3, 3
            }, new byte[] {
                3, 4
            }, new byte[] {
                3, 5
            }, new byte[] {
                3, 6
            }, new byte[] {
                3, 7
            }, new byte[] {
                3, 8
            }, 
            new byte[] {
                3, 9
            }, new byte[] {
                4, 0
            }, new byte[] {
                4, 1
            }, new byte[] {
                4, 2
            }, new byte[] {
                4, 3
            }, new byte[] {
                4, 4
            }, new byte[] {
                4, 5
            }, new byte[] {
                4, 6
            }, new byte[] {
                4, 7
            }, new byte[] {
                4, 8
            }, 
            new byte[] {
                4, 9
            }, new byte[] {
                5, 0
            }, new byte[] {
                5, 1
            }, new byte[] {
                5, 2
            }, new byte[] {
                5, 3
            }, new byte[] {
                5, 4
            }, new byte[] {
                5, 5
            }, new byte[] {
                5, 6
            }, new byte[] {
                5, 7
            }, new byte[] {
                5, 8
            }, 
            new byte[] {
                5, 9
            }, new byte[] {
                6, 0
            }, new byte[] {
                6, 1
            }, new byte[] {
                6, 2
            }, new byte[] {
                6, 3
            }, new byte[] {
                6, 4
            }, new byte[] {
                6, 5
            }, new byte[] {
                6, 6
            }, new byte[] {
                6, 7
            }, new byte[] {
                6, 8
            }, 
            new byte[] {
                6, 9
            }, new byte[] {
                7, 0
            }, new byte[] {
                7, 1
            }, new byte[] {
                7, 2
            }, new byte[] {
                7, 3
            }, new byte[] {
                7, 4
            }, new byte[] {
                7, 5
            }, new byte[] {
                7, 6
            }, new byte[] {
                7, 7
            }, new byte[] {
                7, 8
            }, 
            new byte[] {
                7, 9
            }, new byte[] {
                8, 0
            }, new byte[] {
                8, 1
            }, new byte[] {
                8, 2
            }, new byte[] {
                8, 3
            }, new byte[] {
                8, 4
            }, new byte[] {
                8, 5
            }, new byte[] {
                8, 6
            }, new byte[] {
                8, 7
            }, new byte[] {
                8, 8
            }, 
            new byte[] {
                8, 9
            }, new byte[] {
                9, 0
            }, new byte[] {
                9, 1
            }, new byte[] {
                9, 2
            }, new byte[] {
                9, 3
            }, new byte[] {
                9, 4
            }, new byte[] {
                9, 5
            }, new byte[] {
                9, 6
            }, new byte[] {
                9, 7
            }, new byte[] {
                9, 8
            }, 
            new byte[] {
                9, 9
            }
        }); */
        /* LnxqComponents_N = (new byte[][] {
            new byte[2], new byte[2], new byte[] {
                9, 9
            }, new byte[] {
                9, 8
            }, new byte[] {
                9, 7
            }, new byte[] {
                9, 6
            }, new byte[] {
                9, 5
            }, new byte[] {
                9, 4
            }, new byte[] {
                9, 3
            }, new byte[] {
                9, 2
            }, 
            new byte[] {
                9, 1
            }, new byte[] {
                9, 0
            }, new byte[] {
                8, 9
            }, new byte[] {
                8, 8
            }, new byte[] {
                8, 7
            }, new byte[] {
                8, 6
            }, new byte[] {
                8, 5
            }, new byte[] {
                8, 4
            }, new byte[] {
                8, 3
            }, new byte[] {
                8, 2
            }, 
            new byte[] {
                8, 1
            }, new byte[] {
                8, 0
            }, new byte[] {
                7, 9
            }, new byte[] {
                7, 8
            }, new byte[] {
                7, 7
            }, new byte[] {
                7, 6
            }, new byte[] {
                7, 5
            }, new byte[] {
                7, 4
            }, new byte[] {
                7, 3
            }, new byte[] {
                7, 2
            }, 
            new byte[] {
                7, 1
            }, new byte[] {
                7, 0
            }, new byte[] {
                6, 9
            }, new byte[] {
                6, 8
            }, new byte[] {
                6, 7
            }, new byte[] {
                6, 6
            }, new byte[] {
                6, 5
            }, new byte[] {
                6, 4
            }, new byte[] {
                6, 3
            }, new byte[] {
                6, 2
            }, 
            new byte[] {
                6, 1
            }, new byte[] {
                6, 0
            }, new byte[] {
                5, 9
            }, new byte[] {
                5, 8
            }, new byte[] {
                5, 7
            }, new byte[] {
                5, 6
            }, new byte[] {
                5, 5
            }, new byte[] {
                5, 4
            }, new byte[] {
                5, 3
            }, new byte[] {
                5, 2
            }, 
            new byte[] {
                5, 1
            }, new byte[] {
                5, 0
            }, new byte[] {
                4, 9
            }, new byte[] {
                4, 8
            }, new byte[] {
                4, 7
            }, new byte[] {
                4, 6
            }, new byte[] {
                4, 5
            }, new byte[] {
                4, 4
            }, new byte[] {
                4, 3
            }, new byte[] {
                4, 2
            }, 
            new byte[] {
                4, 1
            }, new byte[] {
                4, 0
            }, new byte[] {
                3, 9
            }, new byte[] {
                3, 8
            }, new byte[] {
                3, 7
            }, new byte[] {
                3, 6
            }, new byte[] {
                3, 5
            }, new byte[] {
                3, 4
            }, new byte[] {
                3, 3
            }, new byte[] {
                3, 2
            }, 
            new byte[] {
                3, 1
            }, new byte[] {
                3, 0
            }, new byte[] {
                2, 9
            }, new byte[] {
                2, 8
            }, new byte[] {
                2, 7
            }, new byte[] {
                2, 6
            }, new byte[] {
                2, 5
            }, new byte[] {
                2, 4
            }, new byte[] {
                2, 3
            }, new byte[] {
                2, 2
            }, 
            new byte[] {
                2, 1
            }, new byte[] {
                2, 0
            }, new byte[] {
                1, 9
            }, new byte[] {
                1, 8
            }, new byte[] {
                1, 7
            }, new byte[] {
                1, 6
            }, new byte[] {
                1, 5
            }, new byte[] {
                1, 4
            }, new byte[] {
                1, 3
            }, new byte[] {
                1, 2
            }, 
            new byte[] {
                1, 1
            }, new byte[] {
                1, 0
            }, new byte[] {
                0, 9
            }, new byte[] {
                0, 8
            }, new byte[] {
                0, 7
            }, new byte[] {
                0, 6
            }, new byte[] {
                0, 5
            }, new byte[] {
                0, 4
            }, new byte[] {
                0, 3
            }, new byte[] {
                0, 2
            }, 
            new byte[] {
                0, 1
            }, new byte[2]
        }); */
        /* LnxqAdd_PPP = (new byte[][] {
            new byte[2], new byte[] {
                0, 1
            }, new byte[] {
                1, 0
            }, new byte[] {
                2, 0
            }, new byte[] {
                3, 0
            }, new byte[] {
                4, 0
            }, new byte[] {
                5, 0
            }, new byte[] {
                6, 0
            }, new byte[] {
                7, 0
            }, new byte[] {
                8, 0
            }, 
            new byte[] {
                9, 0
            }, new byte[] {
                10, 0
            }, new byte[] {
                11, 0
            }, new byte[] {
                12, 0
            }, new byte[] {
                13, 0
            }, new byte[] {
                14, 0
            }, new byte[] {
                15, 0
            }, new byte[] {
                16, 0
            }, new byte[] {
                17, 0
            }, new byte[] {
                18, 0
            }, 
            new byte[] {
                19, 0
            }, new byte[] {
                20, 0
            }, new byte[] {
                21, 0
            }, new byte[] {
                22, 0
            }, new byte[] {
                23, 0
            }, new byte[] {
                24, 0
            }, new byte[] {
                25, 0
            }, new byte[] {
                26, 0
            }, new byte[] {
                27, 0
            }, new byte[] {
                28, 0
            }, 
            new byte[] {
                29, 0
            }, new byte[] {
                30, 0
            }, new byte[] {
                31, 0
            }, new byte[] {
                32, 0
            }, new byte[] {
                33, 0
            }, new byte[] {
                34, 0
            }, new byte[] {
                35, 0
            }, new byte[] {
                36, 0
            }, new byte[] {
                37, 0
            }, new byte[] {
                38, 0
            }, 
            new byte[] {
                39, 0
            }, new byte[] {
                40, 0
            }, new byte[] {
                41, 0
            }, new byte[] {
                42, 0
            }, new byte[] {
                43, 0
            }, new byte[] {
                44, 0
            }, new byte[] {
                45, 0
            }, new byte[] {
                46, 0
            }, new byte[] {
                47, 0
            }, new byte[] {
                48, 0
            }, 
            new byte[] {
                49, 0
            }, new byte[] {
                50, 0
            }, new byte[] {
                51, 0
            }, new byte[] {
                52, 0
            }, new byte[] {
                53, 0
            }, new byte[] {
                54, 0
            }, new byte[] {
                55, 0
            }, new byte[] {
                56, 0
            }, new byte[] {
                57, 0
            }, new byte[] {
                58, 0
            }, 
            new byte[] {
                59, 0
            }, new byte[] {
                60, 0
            }, new byte[] {
                61, 0
            }, new byte[] {
                62, 0
            }, new byte[] {
                63, 0
            }, new byte[] {
                64, 0
            }, new byte[] {
                65, 0
            }, new byte[] {
                66, 0
            }, new byte[] {
                67, 0
            }, new byte[] {
                68, 0
            }, 
            new byte[] {
                69, 0
            }, new byte[] {
                70, 0
            }, new byte[] {
                71, 0
            }, new byte[] {
                72, 0
            }, new byte[] {
                73, 0
            }, new byte[] {
                74, 0
            }, new byte[] {
                75, 0
            }, new byte[] {
                76, 0
            }, new byte[] {
                77, 0
            }, new byte[] {
                78, 0
            }, 
            new byte[] {
                79, 0
            }, new byte[] {
                80, 0
            }, new byte[] {
                81, 0
            }, new byte[] {
                82, 0
            }, new byte[] {
                83, 0
            }, new byte[] {
                84, 0
            }, new byte[] {
                85, 0
            }, new byte[] {
                86, 0
            }, new byte[] {
                87, 0
            }, new byte[] {
                88, 0
            }, 
            new byte[] {
                89, 0
            }, new byte[] {
                90, 0
            }, new byte[] {
                91, 0
            }, new byte[] {
                92, 0
            }, new byte[] {
                93, 0
            }, new byte[] {
                94, 0
            }, new byte[] {
                95, 0
            }, new byte[] {
                96, 0
            }, new byte[] {
                97, 0
            }, new byte[] {
                98, 0
            }, 
            new byte[] {
                99, 0
            }, new byte[] {
                100, 0
            }, new byte[] {
                1, 1
            }, new byte[] {
                2, 1
            }, new byte[] {
                3, 1
            }, new byte[] {
                4, 1
            }, new byte[] {
                5, 1
            }, new byte[] {
                6, 1
            }, new byte[] {
                7, 1
            }, new byte[] {
                8, 1
            }, 
            new byte[] {
                9, 1
            }, new byte[] {
                10, 1
            }, new byte[] {
                11, 1
            }, new byte[] {
                12, 1
            }, new byte[] {
                13, 1
            }, new byte[] {
                14, 1
            }, new byte[] {
                15, 1
            }, new byte[] {
                16, 1
            }, new byte[] {
                17, 1
            }, new byte[] {
                18, 1
            }, 
            new byte[] {
                19, 1
            }, new byte[] {
                20, 1
            }, new byte[] {
                21, 1
            }, new byte[] {
                22, 1
            }, new byte[] {
                23, 1
            }, new byte[] {
                24, 1
            }, new byte[] {
                25, 1
            }, new byte[] {
                26, 1
            }, new byte[] {
                27, 1
            }, new byte[] {
                28, 1
            }, 
            new byte[] {
                29, 1
            }, new byte[] {
                30, 1
            }, new byte[] {
                31, 1
            }, new byte[] {
                32, 1
            }, new byte[] {
                33, 1
            }, new byte[] {
                34, 1
            }, new byte[] {
                35, 1
            }, new byte[] {
                36, 1
            }, new byte[] {
                37, 1
            }, new byte[] {
                38, 1
            }, 
            new byte[] {
                39, 1
            }, new byte[] {
                40, 1
            }, new byte[] {
                41, 1
            }, new byte[] {
                42, 1
            }, new byte[] {
                43, 1
            }, new byte[] {
                44, 1
            }, new byte[] {
                45, 1
            }, new byte[] {
                46, 1
            }, new byte[] {
                47, 1
            }, new byte[] {
                48, 1
            }, 
            new byte[] {
                49, 1
            }, new byte[] {
                50, 1
            }, new byte[] {
                51, 1
            }, new byte[] {
                52, 1
            }, new byte[] {
                53, 1
            }, new byte[] {
                54, 1
            }, new byte[] {
                55, 1
            }, new byte[] {
                56, 1
            }, new byte[] {
                57, 1
            }, new byte[] {
                58, 1
            }, 
            new byte[] {
                59, 1
            }, new byte[] {
                60, 1
            }, new byte[] {
                61, 1
            }, new byte[] {
                62, 1
            }, new byte[] {
                63, 1
            }, new byte[] {
                64, 1
            }, new byte[] {
                65, 1
            }, new byte[] {
                66, 1
            }, new byte[] {
                67, 1
            }, new byte[] {
                68, 1
            }, 
            new byte[] {
                69, 1
            }, new byte[] {
                70, 1
            }, new byte[] {
                71, 1
            }, new byte[] {
                72, 1
            }, new byte[] {
                73, 1
            }, new byte[] {
                74, 1
            }, new byte[] {
                75, 1
            }, new byte[] {
                76, 1
            }, new byte[] {
                77, 1
            }, new byte[] {
                78, 1
            }, 
            new byte[] {
                79, 1
            }, new byte[] {
                80, 1
            }, new byte[] {
                81, 1
            }, new byte[] {
                82, 1
            }, new byte[] {
                83, 1
            }, new byte[] {
                84, 1
            }, new byte[] {
                85, 1
            }, new byte[] {
                86, 1
            }, new byte[] {
                87, 1
            }, new byte[] {
                88, 1
            }, 
            new byte[] {
                89, 1
            }, new byte[] {
                90, 1
            }, new byte[] {
                91, 1
            }, new byte[] {
                92, 1
            }, new byte[] {
                93, 1
            }, new byte[] {
                94, 1
            }, new byte[] {
                95, 1
            }, new byte[] {
                96, 1
            }, new byte[] {
                97, 1
            }, new byte[] {
                98, 1
            }, 
            new byte[] {
                99, 1
            }, new byte[] {
                100, 1
            }
        }); */
        /* LnxqAdd_NNN = (new byte[][] {
            new byte[] {
                0, 2
            }, new byte[] {
                0, 1
            }, new byte[2], new byte[2], new byte[2], new byte[] {
                2, 1
            }, new byte[] {
                3, 1
            }, new byte[] {
                4, 1
            }, new byte[] {
                5, 1
            }, new byte[] {
                6, 1
            }, new byte[] {
                7, 1
            }, new byte[] {
                8, 1
            }, new byte[] {
                9, 1
            }, new byte[] {
                10, 1
            }, new byte[] {
                11, 1
            }, new byte[] {
                12, 1
            }, new byte[] {
                13, 1
            }, new byte[] {
                14, 1
            }, new byte[] {
                15, 1
            }, new byte[] {
                16, 1
            }, new byte[] {
                17, 1
            }, new byte[] {
                18, 1
            }, new byte[] {
                19, 1
            }, new byte[] {
                20, 1
            }, new byte[] {
                21, 1
            }, new byte[] {
                22, 1
            }, new byte[] {
                23, 1
            }, new byte[] {
                24, 1
            }, new byte[] {
                25, 1
            }, new byte[] {
                26, 1
            }, new byte[] {
                27, 1
            }, new byte[] {
                28, 1
            }, new byte[] {
                29, 1
            }, new byte[] {
                30, 1
            }, new byte[] {
                31, 1
            }, new byte[] {
                32, 1
            }, new byte[] {
                33, 1
            }, new byte[] {
                34, 1
            }, new byte[] {
                35, 1
            }, new byte[] {
                36, 1
            }, new byte[] {
                37, 1
            }, new byte[] {
                38, 1
            }, new byte[] {
                39, 1
            }, new byte[] {
                40, 1
            }, new byte[] {
                41, 1
            }, new byte[] {
                42, 1
            }, new byte[] {
                43, 1
            }, new byte[] {
                44, 1
            }, new byte[] {
                45, 1
            }, new byte[] {
                46, 1
            }, new byte[] {
                47, 1
            }, new byte[] {
                48, 1
            }, new byte[] {
                49, 1
            }, new byte[] {
                50, 1
            }, new byte[] {
                51, 1
            }, new byte[] {
                52, 1
            }, new byte[] {
                53, 1
            }, new byte[] {
                54, 1
            }, new byte[] {
                55, 1
            }, new byte[] {
                56, 1
            }, new byte[] {
                57, 1
            }, new byte[] {
                58, 1
            }, new byte[] {
                59, 1
            }, new byte[] {
                60, 1
            }, new byte[] {
                61, 1
            }, new byte[] {
                62, 1
            }, new byte[] {
                63, 1
            }, new byte[] {
                64, 1
            }, new byte[] {
                65, 1
            }, new byte[] {
                66, 1
            }, new byte[] {
                67, 1
            }, new byte[] {
                68, 1
            }, new byte[] {
                69, 1
            }, new byte[] {
                70, 1
            }, new byte[] {
                71, 1
            }, new byte[] {
                72, 1
            }, new byte[] {
                73, 1
            }, new byte[] {
                74, 1
            }, new byte[] {
                75, 1
            }, new byte[] {
                76, 1
            }, new byte[] {
                77, 1
            }, new byte[] {
                78, 1
            }, new byte[] {
                79, 1
            }, new byte[] {
                80, 1
            }, new byte[] {
                81, 1
            }, new byte[] {
                82, 1
            }, new byte[] {
                83, 1
            }, new byte[] {
                84, 1
            }, new byte[] {
                85, 1
            }, new byte[] {
                86, 1
            }, new byte[] {
                87, 1
            }, new byte[] {
                88, 1
            }, new byte[] {
                89, 1
            }, new byte[] {
                90, 1
            }, new byte[] {
                91, 1
            }, new byte[] {
                92, 1
            }, new byte[] {
                93, 1
            }, new byte[] {
                94, 1
            }, new byte[] {
                95, 1
            }, new byte[] {
                96, 1
            }, new byte[] {
                97, 1
            }, new byte[] {
                98, 1
            }, new byte[] {
                99, 1
            }, new byte[] {
                100, 1
            }, new byte[] {
                101, 1
            }, new byte[] {
                2, 2
            }, new byte[] {
                3, 2
            }, new byte[] {
                4, 2
            }, new byte[] {
                5, 2
            }, new byte[] {
                6, 2
            }, new byte[] {
                7, 2
            }, new byte[] {
                8, 2
            }, new byte[] {
                9, 2
            }, new byte[] {
                10, 2
            }, new byte[] {
                11, 2
            }, new byte[] {
                12, 2
            }, new byte[] {
                13, 2
            }, new byte[] {
                14, 2
            }, new byte[] {
                15, 2
            }, new byte[] {
                16, 2
            }, new byte[] {
                17, 2
            }, new byte[] {
                18, 2
            }, new byte[] {
                19, 2
            }, new byte[] {
                20, 2
            }, new byte[] {
                21, 2
            }, new byte[] {
                22, 2
            }, new byte[] {
                23, 2
            }, new byte[] {
                24, 2
            }, new byte[] {
                25, 2
            }, new byte[] {
                26, 2
            }, new byte[] {
                27, 2
            }, new byte[] {
                28, 2
            }, new byte[] {
                29, 2
            }, new byte[] {
                30, 2
            }, new byte[] {
                31, 2
            }, new byte[] {
                32, 2
            }, new byte[] {
                33, 2
            }, new byte[] {
                34, 2
            }, new byte[] {
                35, 2
            }, new byte[] {
                36, 2
            }, new byte[] {
                37, 2
            }, new byte[] {
                38, 2
            }, new byte[] {
                39, 2
            }, new byte[] {
                40, 2
            }, new byte[] {
                41, 2
            }, new byte[] {
                42, 2
            }, new byte[] {
                43, 2
            }, new byte[] {
                44, 2
            }, new byte[] {
                45, 2
            }, new byte[] {
                46, 2
            }, new byte[] {
                47, 2
            }, new byte[] {
                48, 2
            }, new byte[] {
                49, 2
            }, new byte[] {
                50, 2
            }, new byte[] {
                51, 2
            }, new byte[] {
                52, 2
            }, new byte[] {
                53, 2
            }, new byte[] {
                54, 2
            }, new byte[] {
                55, 2
            }, new byte[] {
                56, 2
            }, new byte[] {
                57, 2
            }, new byte[] {
                58, 2
            }, new byte[] {
                59, 2
            }, new byte[] {
                60, 2
            }, new byte[] {
                61, 2
            }, new byte[] {
                62, 2
            }, new byte[] {
                63, 2
            }, new byte[] {
                64, 2
            }, new byte[] {
                65, 2
            }, new byte[] {
                66, 2
            }, new byte[] {
                67, 2
            }, new byte[] {
                68, 2
            }, new byte[] {
                69, 2
            }, new byte[] {
                70, 2
            }, new byte[] {
                71, 2
            }, new byte[] {
                72, 2
            }, new byte[] {
                73, 2
            }, new byte[] {
                74, 2
            }, new byte[] {
                75, 2
            }, new byte[] {
                76, 2
            }, new byte[] {
                77, 2
            }, new byte[] {
                78, 2
            }, new byte[] {
                79, 2
            }, new byte[] {
                80, 2
            }, new byte[] {
                81, 2
            }, new byte[] {
                82, 2
            }, new byte[] {
                83, 2
            }, new byte[] {
                84, 2
            }, new byte[] {
                85, 2
            }, new byte[] {
                86, 2
            }, new byte[] {
                87, 2
            }, new byte[] {
                88, 2
            }, new byte[] {
                89, 2
            }, new byte[] {
                90, 2
            }, new byte[] {
                91, 2
            }, new byte[] {
                92, 2
            }, new byte[] {
                93, 2
            }, new byte[] {
                94, 2
            }, new byte[] {
                95, 2
            }, new byte[] {
                96, 2
            }, new byte[] {
                97, 2
            }, new byte[] {
                98, 2
            }, new byte[] {
                99, 2
            }, new byte[] {
                100, 2
            }, new byte[] {
                101, 2
            }
        }); */
        /* LnxqAdd_PNP = (new byte[][] {
            new byte[] {
                0, 2
            }, new byte[] {
                0, 1
            }, new byte[2], new byte[2], new byte[] {
                1, 1
            }, new byte[] {
                2, 1
            }, new byte[] {
                3, 1
            }, new byte[] {
                4, 1
            }, new byte[] {
                5, 1
            }, new byte[] {
                6, 1
            }, new byte[] {
                7, 1
            }, new byte[] {
                8, 1
            }, new byte[] {
                9, 1
            }, new byte[] {
                10, 1
            }, new byte[] {
                11, 1
            }, new byte[] {
                12, 1
            }, new byte[] {
                13, 1
            }, new byte[] {
                14, 1
            }, new byte[] {
                15, 1
            }, new byte[] {
                16, 1
            }, new byte[] {
                17, 1
            }, new byte[] {
                18, 1
            }, new byte[] {
                19, 1
            }, new byte[] {
                20, 1
            }, new byte[] {
                21, 1
            }, new byte[] {
                22, 1
            }, new byte[] {
                23, 1
            }, new byte[] {
                24, 1
            }, new byte[] {
                25, 1
            }, new byte[] {
                26, 1
            }, new byte[] {
                27, 1
            }, new byte[] {
                28, 1
            }, new byte[] {
                29, 1
            }, new byte[] {
                30, 1
            }, new byte[] {
                31, 1
            }, new byte[] {
                32, 1
            }, new byte[] {
                33, 1
            }, new byte[] {
                34, 1
            }, new byte[] {
                35, 1
            }, new byte[] {
                36, 1
            }, new byte[] {
                37, 1
            }, new byte[] {
                38, 1
            }, new byte[] {
                39, 1
            }, new byte[] {
                40, 1
            }, new byte[] {
                41, 1
            }, new byte[] {
                42, 1
            }, new byte[] {
                43, 1
            }, new byte[] {
                44, 1
            }, new byte[] {
                45, 1
            }, new byte[] {
                46, 1
            }, new byte[] {
                47, 1
            }, new byte[] {
                48, 1
            }, new byte[] {
                49, 1
            }, new byte[] {
                50, 1
            }, new byte[] {
                51, 1
            }, new byte[] {
                52, 1
            }, new byte[] {
                53, 1
            }, new byte[] {
                54, 1
            }, new byte[] {
                55, 1
            }, new byte[] {
                56, 1
            }, new byte[] {
                57, 1
            }, new byte[] {
                58, 1
            }, new byte[] {
                59, 1
            }, new byte[] {
                60, 1
            }, new byte[] {
                61, 1
            }, new byte[] {
                62, 1
            }, new byte[] {
                63, 1
            }, new byte[] {
                64, 1
            }, new byte[] {
                65, 1
            }, new byte[] {
                66, 1
            }, new byte[] {
                67, 1
            }, new byte[] {
                68, 1
            }, new byte[] {
                69, 1
            }, new byte[] {
                70, 1
            }, new byte[] {
                71, 1
            }, new byte[] {
                72, 1
            }, new byte[] {
                73, 1
            }, new byte[] {
                74, 1
            }, new byte[] {
                75, 1
            }, new byte[] {
                76, 1
            }, new byte[] {
                77, 1
            }, new byte[] {
                78, 1
            }, new byte[] {
                79, 1
            }, new byte[] {
                80, 1
            }, new byte[] {
                81, 1
            }, new byte[] {
                82, 1
            }, new byte[] {
                83, 1
            }, new byte[] {
                84, 1
            }, new byte[] {
                85, 1
            }, new byte[] {
                86, 1
            }, new byte[] {
                87, 1
            }, new byte[] {
                88, 1
            }, new byte[] {
                89, 1
            }, new byte[] {
                90, 1
            }, new byte[] {
                91, 1
            }, new byte[] {
                92, 1
            }, new byte[] {
                93, 1
            }, new byte[] {
                94, 1
            }, new byte[] {
                95, 1
            }, new byte[] {
                96, 1
            }, new byte[] {
                97, 1
            }, new byte[] {
                98, 1
            }, new byte[] {
                99, 1
            }, new byte[] {
                100, 1
            }, new byte[] {
                1, 2
            }, new byte[] {
                2, 2
            }, new byte[] {
                3, 2
            }, new byte[] {
                4, 2
            }, new byte[] {
                5, 2
            }, new byte[] {
                6, 2
            }, new byte[] {
                7, 2
            }, new byte[] {
                8, 2
            }, new byte[] {
                9, 2
            }, new byte[] {
                10, 2
            }, new byte[] {
                11, 2
            }, new byte[] {
                12, 2
            }, new byte[] {
                13, 2
            }, new byte[] {
                14, 2
            }, new byte[] {
                15, 2
            }, new byte[] {
                16, 2
            }, new byte[] {
                17, 2
            }, new byte[] {
                18, 2
            }, new byte[] {
                19, 2
            }, new byte[] {
                20, 2
            }, new byte[] {
                21, 2
            }, new byte[] {
                22, 2
            }, new byte[] {
                23, 2
            }, new byte[] {
                24, 2
            }, new byte[] {
                25, 2
            }, new byte[] {
                26, 2
            }, new byte[] {
                27, 2
            }, new byte[] {
                28, 2
            }, new byte[] {
                29, 2
            }, new byte[] {
                30, 2
            }, new byte[] {
                31, 2
            }, new byte[] {
                32, 2
            }, new byte[] {
                33, 2
            }, new byte[] {
                34, 2
            }, new byte[] {
                35, 2
            }, new byte[] {
                36, 2
            }, new byte[] {
                37, 2
            }, new byte[] {
                38, 2
            }, new byte[] {
                39, 2
            }, new byte[] {
                40, 2
            }, new byte[] {
                41, 2
            }, new byte[] {
                42, 2
            }, new byte[] {
                43, 2
            }, new byte[] {
                44, 2
            }, new byte[] {
                45, 2
            }, new byte[] {
                46, 2
            }, new byte[] {
                47, 2
            }, new byte[] {
                48, 2
            }, new byte[] {
                49, 2
            }, new byte[] {
                50, 2
            }, new byte[] {
                51, 2
            }, new byte[] {
                52, 2
            }, new byte[] {
                53, 2
            }, new byte[] {
                54, 2
            }, new byte[] {
                55, 2
            }, new byte[] {
                56, 2
            }, new byte[] {
                57, 2
            }, new byte[] {
                58, 2
            }, new byte[] {
                59, 2
            }, new byte[] {
                60, 2
            }, new byte[] {
                61, 2
            }, new byte[] {
                62, 2
            }, new byte[] {
                63, 2
            }, new byte[] {
                64, 2
            }, new byte[] {
                65, 2
            }, new byte[] {
                66, 2
            }, new byte[] {
                67, 2
            }, new byte[] {
                68, 2
            }, new byte[] {
                69, 2
            }, new byte[] {
                70, 2
            }, new byte[] {
                71, 2
            }, new byte[] {
                72, 2
            }, new byte[] {
                73, 2
            }, new byte[] {
                74, 2
            }, new byte[] {
                75, 2
            }, new byte[] {
                76, 2
            }, new byte[] {
                77, 2
            }, new byte[] {
                78, 2
            }, new byte[] {
                79, 2
            }, new byte[] {
                80, 2
            }, new byte[] {
                81, 2
            }, new byte[] {
                82, 2
            }, new byte[] {
                83, 2
            }, new byte[] {
                84, 2
            }, new byte[] {
                85, 2
            }, new byte[] {
                86, 2
            }, new byte[] {
                87, 2
            }, new byte[] {
                88, 2
            }, new byte[] {
                89, 2
            }, new byte[] {
                90, 2
            }, new byte[] {
                91, 2
            }, new byte[] {
                92, 2
            }, new byte[] {
                93, 2
            }, new byte[] {
                94, 2
            }, new byte[] {
                95, 2
            }, new byte[] {
                96, 2
            }, new byte[] {
                97, 2
            }, new byte[] {
                98, 2
            }, new byte[] {
                99, 2
            }, new byte[] {
                100, 2
            }
        }); */
        /* LnxqAdd_PNN = (new byte[][] {
            new byte[2], new byte[] {
                0, 1
            }, new byte[2], new byte[] {
                2, 0
            }, new byte[] {
                3, 0
            }, new byte[] {
                4, 0
            }, new byte[] {
                5, 0
            }, new byte[] {
                6, 0
            }, new byte[] {
                7, 0
            }, new byte[] {
                8, 0
            }, 
            new byte[] {
                9, 0
            }, new byte[] {
                10, 0
            }, new byte[] {
                11, 0
            }, new byte[] {
                12, 0
            }, new byte[] {
                13, 0
            }, new byte[] {
                14, 0
            }, new byte[] {
                15, 0
            }, new byte[] {
                16, 0
            }, new byte[] {
                17, 0
            }, new byte[] {
                18, 0
            }, 
            new byte[] {
                19, 0
            }, new byte[] {
                20, 0
            }, new byte[] {
                21, 0
            }, new byte[] {
                22, 0
            }, new byte[] {
                23, 0
            }, new byte[] {
                24, 0
            }, new byte[] {
                25, 0
            }, new byte[] {
                26, 0
            }, new byte[] {
                27, 0
            }, new byte[] {
                28, 0
            }, 
            new byte[] {
                29, 0
            }, new byte[] {
                30, 0
            }, new byte[] {
                31, 0
            }, new byte[] {
                32, 0
            }, new byte[] {
                33, 0
            }, new byte[] {
                34, 0
            }, new byte[] {
                35, 0
            }, new byte[] {
                36, 0
            }, new byte[] {
                37, 0
            }, new byte[] {
                38, 0
            }, 
            new byte[] {
                39, 0
            }, new byte[] {
                40, 0
            }, new byte[] {
                41, 0
            }, new byte[] {
                42, 0
            }, new byte[] {
                43, 0
            }, new byte[] {
                44, 0
            }, new byte[] {
                45, 0
            }, new byte[] {
                46, 0
            }, new byte[] {
                47, 0
            }, new byte[] {
                48, 0
            }, 
            new byte[] {
                49, 0
            }, new byte[] {
                50, 0
            }, new byte[] {
                51, 0
            }, new byte[] {
                52, 0
            }, new byte[] {
                53, 0
            }, new byte[] {
                54, 0
            }, new byte[] {
                55, 0
            }, new byte[] {
                56, 0
            }, new byte[] {
                57, 0
            }, new byte[] {
                58, 0
            }, 
            new byte[] {
                59, 0
            }, new byte[] {
                60, 0
            }, new byte[] {
                61, 0
            }, new byte[] {
                62, 0
            }, new byte[] {
                63, 0
            }, new byte[] {
                64, 0
            }, new byte[] {
                65, 0
            }, new byte[] {
                66, 0
            }, new byte[] {
                67, 0
            }, new byte[] {
                68, 0
            }, 
            new byte[] {
                69, 0
            }, new byte[] {
                70, 0
            }, new byte[] {
                71, 0
            }, new byte[] {
                72, 0
            }, new byte[] {
                73, 0
            }, new byte[] {
                74, 0
            }, new byte[] {
                75, 0
            }, new byte[] {
                76, 0
            }, new byte[] {
                77, 0
            }, new byte[] {
                78, 0
            }, 
            new byte[] {
                79, 0
            }, new byte[] {
                80, 0
            }, new byte[] {
                81, 0
            }, new byte[] {
                82, 0
            }, new byte[] {
                83, 0
            }, new byte[] {
                84, 0
            }, new byte[] {
                85, 0
            }, new byte[] {
                86, 0
            }, new byte[] {
                87, 0
            }, new byte[] {
                88, 0
            }, 
            new byte[] {
                89, 0
            }, new byte[] {
                90, 0
            }, new byte[] {
                91, 0
            }, new byte[] {
                92, 0
            }, new byte[] {
                93, 0
            }, new byte[] {
                94, 0
            }, new byte[] {
                95, 0
            }, new byte[] {
                96, 0
            }, new byte[] {
                97, 0
            }, new byte[] {
                98, 0
            }, 
            new byte[] {
                99, 0
            }, new byte[] {
                100, 0
            }, new byte[] {
                101, 0
            }, new byte[] {
                2, 1
            }, new byte[] {
                3, 1
            }, new byte[] {
                4, 1
            }, new byte[] {
                5, 1
            }, new byte[] {
                6, 1
            }, new byte[] {
                7, 1
            }, new byte[] {
                8, 1
            }, 
            new byte[] {
                9, 1
            }, new byte[] {
                10, 1
            }, new byte[] {
                11, 1
            }, new byte[] {
                12, 1
            }, new byte[] {
                13, 1
            }, new byte[] {
                14, 1
            }, new byte[] {
                15, 1
            }, new byte[] {
                16, 1
            }, new byte[] {
                17, 1
            }, new byte[] {
                18, 1
            }, 
            new byte[] {
                19, 1
            }, new byte[] {
                20, 1
            }, new byte[] {
                21, 1
            }, new byte[] {
                22, 1
            }, new byte[] {
                23, 1
            }, new byte[] {
                24, 1
            }, new byte[] {
                25, 1
            }, new byte[] {
                26, 1
            }, new byte[] {
                27, 1
            }, new byte[] {
                28, 1
            }, 
            new byte[] {
                29, 1
            }, new byte[] {
                30, 1
            }, new byte[] {
                31, 1
            }, new byte[] {
                32, 1
            }, new byte[] {
                33, 1
            }, new byte[] {
                34, 1
            }, new byte[] {
                35, 1
            }, new byte[] {
                36, 1
            }, new byte[] {
                37, 1
            }, new byte[] {
                38, 1
            }, 
            new byte[] {
                39, 1
            }, new byte[] {
                40, 1
            }, new byte[] {
                41, 1
            }, new byte[] {
                42, 1
            }, new byte[] {
                43, 1
            }, new byte[] {
                44, 1
            }, new byte[] {
                45, 1
            }, new byte[] {
                46, 1
            }, new byte[] {
                47, 1
            }, new byte[] {
                48, 1
            }, 
            new byte[] {
                49, 1
            }, new byte[] {
                50, 1
            }, new byte[] {
                51, 1
            }, new byte[] {
                52, 1
            }, new byte[] {
                53, 1
            }, new byte[] {
                54, 1
            }, new byte[] {
                55, 1
            }, new byte[] {
                56, 1
            }, new byte[] {
                57, 1
            }, new byte[] {
                58, 1
            }, 
            new byte[] {
                59, 1
            }, new byte[] {
                60, 1
            }, new byte[] {
                61, 1
            }, new byte[] {
                62, 1
            }, new byte[] {
                63, 1
            }, new byte[] {
                64, 1
            }, new byte[] {
                65, 1
            }, new byte[] {
                66, 1
            }, new byte[] {
                67, 1
            }, new byte[] {
                68, 1
            }, 
            new byte[] {
                69, 1
            }, new byte[] {
                70, 1
            }, new byte[] {
                71, 1
            }, new byte[] {
                72, 1
            }, new byte[] {
                73, 1
            }, new byte[] {
                74, 1
            }, new byte[] {
                75, 1
            }, new byte[] {
                76, 1
            }, new byte[] {
                77, 1
            }, new byte[] {
                78, 1
            }, 
            new byte[] {
                79, 1
            }, new byte[] {
                80, 1
            }, new byte[] {
                81, 1
            }, new byte[] {
                82, 1
            }, new byte[] {
                83, 1
            }, new byte[] {
                84, 1
            }, new byte[] {
                85, 1
            }, new byte[] {
                86, 1
            }, new byte[] {
                87, 1
            }, new byte[] {
                88, 1
            }, 
            new byte[] {
                89, 1
            }, new byte[] {
                90, 1
            }, new byte[] {
                91, 1
            }, new byte[] {
                92, 1
            }, new byte[] {
                93, 1
            }, new byte[] {
                94, 1
            }, new byte[] {
                95, 1
            }, new byte[] {
                96, 1
            }, new byte[] {
                97, 1
            }, new byte[] {
                98, 1
            }, 
            new byte[] {
                99, 1
            }, new byte[] {
                100, 1
            }, new byte[] {
                101, 1
            }
        }); */
        /* LnxsubIdentity = (new byte[] {
            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 
            10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
            20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
            30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 
            40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 
            50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 
            60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 
            70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 
            80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 
            90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 
            100, 101
        }); */
        /* LnxqDigit_P = (new byte[][] {
            new byte[] {
                1, 2, 3, 4, 5, 6, 7, 8, 9, 10
            }, new byte[] {
                11, 12, 13, 14, 15, 16, 17, 18, 19, 20
            }, new byte[] {
                21, 22, 23, 24, 25, 26, 27, 28, 29, 30
            }, new byte[] {
                31, 32, 33, 34, 35, 36, 37, 38, 39, 40
            }, new byte[] {
                41, 42, 43, 44, 45, 46, 47, 48, 49, 50
            }, new byte[] {
                51, 52, 53, 54, 55, 56, 57, 58, 59, 60
            }, new byte[] {
                61, 62, 63, 64, 65, 66, 67, 68, 69, 70
            }, new byte[] {
                71, 72, 73, 74, 75, 76, 77, 78, 79, 80
            }, new byte[] {
                81, 82, 83, 84, 85, 86, 87, 88, 89, 90
            }, new byte[] {
                91, 92, 93, 94, 95, 96, 97, 98, 99, 100
            }
        }); */
        /* LnxqDigit_N = (new byte[][] {
            new byte[] {
                101, 100, 99, 98, 97, 96, 95, 94, 93, 92
            }, new byte[] {
                91, 90, 89, 88, 87, 86, 85, 84, 83, 82
            }, new byte[] {
                81, 80, 79, 78, 77, 76, 75, 74, 73, 72
            }, new byte[] {
                71, 70, 69, 68, 67, 66, 65, 64, 63, 62
            }, new byte[] {
                61, 60, 59, 58, 57, 56, 55, 54, 53, 52
            }, new byte[] {
                51, 50, 49, 48, 47, 46, 45, 44, 43, 42
            }, new byte[] {
                41, 40, 39, 38, 37, 36, 35, 34, 33, 32
            }, new byte[] {
                31, 30, 29, 28, 27, 26, 25, 24, 23, 22
            }, new byte[] {
                21, 20, 19, 18, 17, 16, 15, 14, 13, 12
            }, new byte[] {
                11, 10, 9, 8, 7, 6, 5, 4, 3, 2
            }
        }); */
        /* powerTable = (new double[][] {
            new double[] {
                128D, 1E+256D, 9.9999999999999998E-257D
            }, new double[] {
                64D, 1.0000000000000001E+128D, 1.0000000000000001E-128D
            }, new double[] {
                32D, 1E+64D, 9.9999999999999997E-65D
            }, new double[] {
                16D, 1.0000000000000001E+32D, 1.0000000000000001E-32D
            }, new double[] {
                8D, 10000000000000000D, 9.9999999999999998E-17D
            }, new double[] {
                4D, 100000000D, 1E-08D
            }, new double[] {
                2D, 10000D, 0.0001D
            }, new double[] {
                1.0D, 100D, 0.01D
            }
        }); */
        /* factorTable = (new double[][] {
            new double[] {
                15D, 1E+30D, 1.0000000000000001E-30D
            }, new double[] {
                14D, 9.9999999999999996E+27D, 9.9999999999999997E-29D
            }, new double[] {
                13D, 1E+26D, 1E-26D
            }, new double[] {
                12D, 9.9999999999999998E+23D, 9.9999999999999992E-25D
            }, new double[] {
                11D, 1E+22D, 1E-22D
            }, new double[] {
                10D, 1E+20D, 9.9999999999999995E-21D
            }, new double[] {
                9D, 1E+18D, 1.0000000000000001E-18D
            }, new double[] {
                8D, 10000000000000000D, 9.9999999999999998E-17D
            }, new double[] {
                7D, 100000000000000D, 1E-14D
            }, new double[] {
                6D, 1000000000000D, 9.9999999999999998E-13D
            }, new double[] {
                5D, 10000000000D, 1E-10D
            }, new double[] {
                4D, 100000000D, 1E-08D
            }, new double[] {
                3D, 1000000D, 9.9999999999999995E-07D
            }, new double[] {
                2D, 10000D, 0.0001D
            }, new double[] {
                1.0D, 100D, 0.01D
            }, new double[] {
                0, 1.0D, 1.0D
            }, new double[] {
                -1D, 0.01D, 100D
            }, new double[] {
                -2D, 0.0001D, 10000D
            }, new double[] {
                -3D, 9.9999999999999995E-07D, 1000000D
            }, new double[] {
                -4D, 1E-08D, 100000000D
            }, new double[] {
                -5D, 1E-10D, 10000000000D
            }, new double[] {
                -6D, 9.9999999999999998E-13D, 1000000000000D
            }, new double[] {
                -7D, 1E-14D, 100000000000000D
            }, new double[] {
                -8D, 9.9999999999999998E-17D, 10000000000000000D
            }, new double[] {
                -9D, 1.0000000000000001E-18D, 1E+18D
            }, new double[] {
                -10D, 9.9999999999999995E-21D, 1E+20D
            }, new double[] {
                -11D, 1E-22D, 1E+22D
            }, new double[] {
                -12D, 9.9999999999999992E-25D, 9.9999999999999998E+23D
            }, new double[] {
                -13D, 1E-26D, 1E+26D
            }, new double[] {
                -14D, 9.9999999999999997E-29D, 9.9999999999999996E+27D
            }, new double[] {
                -15D, 1.0000000000000001E-30D, 1E+30D
            }, new double[] {
                -16D, 1.0000000000000001E-32D, 1.0000000000000001E+32D
            }, new double[] {
                -17D, 9.9999999999999993E-35D, 9.9999999999999995E+33D
            }, new double[] {
                -18D, 9.9999999999999994E-37D, 1E+36D
            }, new double[] {
                -19D, 9.9999999999999996E-39D, 9.9999999999999998E+37D
            }, new double[] {
                -20D, 9.9999999999999993E-41D, 1E+40D
            }, new double[] {
                -21D, 1E-42D, 1E+42D
            }, new double[] {
                -22D, 9.9999999999999995E-45D, 1.0000000000000001E+44D
            }, new double[] {
                -23D, 1E-46D, 9.9999999999999999E+45D
            }, new double[] {
                -24D, 9.9999999999999997E-49D, 1E+48D
            }, new double[] {
                -25D, 1E-50D, 1.0000000000000001E+50D
            }, new double[] {
                -26D, 1E-52D, 9.9999999999999999E+51D
            }, new double[] {
                -27D, 1E-54D, 1.0000000000000001E+54D
            }, new double[] {
                -28D, 1E-56D, 1.0000000000000001E+56D
            }, new double[] {
                -29D, 1E-58D, 9.9999999999999994E+57D
            }, new double[] {
                -30D, 9.9999999999999997E-61D, 9.9999999999999995E+59D
            }, new double[] {
                -31D, 1E-62D, 1E+62D
            }, new double[] {
                -32D, 9.9999999999999997E-65D, 1E+64D
            }, new double[] {
                -33D, 9.9999999999999998E-67D, 9.9999999999999995E+65D
            }, new double[] {
                -34D, 1.0000000000000001E-68D, 9.9999999999999995E+67D
            }
        }); */
    }
}