PHP Decode

<?php


namespace MiniOrange\OAuth\Helper;

define("\102\111\x47\111\116\124\x45\107\x45\122\137\x4d\117\x4e\124\107\117\115\105\x52\x59", 0<?php


namespace MiniOrange\OAuth\Model;

class MiniorangeOauthClientApps extends \Magento\Framework\Model\AbstractModel
{
    public function _construct()
    {
        $this->_init("\115\151\x6e\151\x4f\x72\141\x6e\147\145\x5c\117\x41\165\x74\150\x5c\x4d\157\x64\x65\x6c\x5c\122\145\x73\157\165\162\143\x65\115\x6f\144\x65\154\134\115\151\156\151\117\x72\141\x6e\x67\x65\117\x61\165\164\150\103\154\x69\x65\156\164\101\160\x70\163");
    }
}
);
define("\x42\x49\107\x49\x4e\x54\x45\107\105\122\137\102\101\122\122\x45\124\124", 1);
define("\102\111\107\x49\x4e\x54\105\x47\105\122\137\120\x4f\x57\x45\x52\117\x46\x32", 2);
define("\102\111\107\111\x4e\124\105\107\105\122\137\x43\114\x41\x53\123\111\103", 3);
define("\x42\x49\107\x49\116\124\x45\x47\105\122\x5f\x4e\117\116\105", 4);
define("\x42\111\x47\111\116\124\x45\107\105\122\137\x56\x41\114\125\105", 0);
define("\x42\x49\107\x49\x4e\124\x45\107\105\x52\x5f\123\x49\107\116", 1);
define("\x42\x49\107\111\116\x54\x45\x47\x45\x52\137\x56\101\x52\111\101\x42\114\105", 0);
define("\102\x49\107\111\116\x54\x45\x47\x45\x52\x5f\104\101\124\101", 1);
define("\102\x49\x47\111\x4e\x54\105\x47\105\x52\x5f\115\x4f\x44\105\x5f\111\116\x54\105\122\x4e\101\114", 1);
define("\102\111\x47\x49\116\124\105\107\x45\122\137\x4d\x4f\104\105\x5f\x42\103\115\101\x54\x48", 2);
define("\x42\x49\x47\111\116\124\105\107\x45\122\x5f\115\117\104\105\x5f\x47\115\x50", 3);
define("\102\111\x47\111\x4e\x54\x45\107\105\x52\137\113\101\122\x41\x54\123\125\x42\x41\137\103\125\124\x4f\106\x46", 25);
class BigInteger
{
    var $value;
    var $is_negative = false;
    var $precision = -1;
    var $bitmask = false;
    var $hex;
    function __construct($gJ = 0, $X6 = 10)
    {
        if (defined("\x42\111\x47\x49\x4e\x54\105\107\x45\122\137\x4d\117\x44\x45")) {
            goto di;
        }
        switch (true) {
            case extension_loaded("\x67\x6d\x70"):
                define("\102\x49\x47\x49\116\124\x45\107\x45\x52\x5f\x4d\117\104\105", BIGINTEGER_MODE_GMP);
                goto Z8;
            case extension_loaded("\x62\143\x6d\x61\x74\150"):
                define("\102\111\107\x49\x4e\x54\x45\107\105\x52\x5f\x4d\117\x44\x45", BIGINTEGER_MODE_BCMATH);
                goto Z8;
            default:
                define("\102\x49\x47\x49\116\124\105\x47\105\122\x5f\115\x4f\x44\105", BIGINTEGER_MODE_INTERNAL);
        }
        zS:
        Z8:
        di:
        if (!(extension_loaded("\157\160\145\x6e\163\x73\154") && !defined("\102\x49\107\111\x4e\124\105\x47\105\122\137\117\x50\x45\116\123\x53\114\137\x44\111\123\101\102\114\105") && !defined("\102\x49\x47\111\116\x54\105\107\105\122\137\x4f\120\x45\116\x53\x53\114\137\105\x4e\x41\x42\x4c\105\x44"))) {
            goto zV;
        }
        ob_start();
        @phpinfo();
        $lk = ob_get_contents();
        ob_end_clean();
        preg_match_all("\43\x4f\x70\145\156\123\123\114\x20\50\110\x65\141\x64\145\162\174\x4c\x69\x62\162\x61\162\171\51\40\126\145\162\163\151\x6f\156\x28\56\52\x29\43\x69\x6d", $lk, $wJ);
        $B3 = array();
        if (empty($wJ[1])) {
            goto Ql;
        }
        $Tu = 0;
        wm:
        if (!($Tu < count($wJ[1]))) {
            goto XZ;
        }
        $wL = trim(str_replace("\x3d\76", '', strip_tags($wJ[2][$Tu])));
        if (!preg_match("\x2f\x28\x5c\144\x2b\x5c\x2e\134\144\x2b\x5c\56\x5c\144\53\51\57\x69", $wL, $qa)) {
            goto C5;
        }
        $B3[$wJ[1][$Tu]] = $qa[0];
        goto qL;
        C5:
        $B3[$wJ[1][$Tu]] = $wL;
        qL:
        iW:
        $Tu++;
        goto wm;
        XZ:
        Ql:
        switch (true) {
            case !isset($B3["\110\145\x61\x64\x65\162"]):
            case !isset($B3["\114\x69\142\x72\x61\x72\171"]):
            case $B3["\110\145\141\x64\x65\162"] == $B3["\114\x69\142\x72\x61\162\171"]:
            case version_compare($B3["\110\x65\141\144\x65\162"], "\61\56\x30\56\x30") >= 0 && version_compare($B3["\114\151\142\162\141\x72\171"], "\x31\x2e\x30\56\60") >= 0:
                define("\102\111\x47\x49\116\124\105\107\x45\122\x5f\x4f\x50\105\x4e\123\123\114\x5f\105\x4e\101\102\x4c\105\104", true);
                goto Sr;
            default:
                define("\102\111\x47\x49\116\124\105\107\105\x52\x5f\x4f\120\105\116\x53\123\x4c\137\x44\x49\x53\x41\102\x4c\105", true);
        }
        rZ:
        Sr:
        zV:
        if (defined("\x50\x48\120\x5f\111\116\124\137\x53\111\132\105")) {
            goto jt;
        }
        define("\x50\x48\x50\x5f\111\116\x54\x5f\123\111\132\x45", 4);
        jt:
        if (!(!defined("\x42\111\x47\111\116\124\x45\107\x45\122\137\x42\x41\123\105") && BIGINTEGER_MODE == BIGINTEGER_MODE_INTERNAL)) {
            goto CM;
        }
        switch (PHP_INT_SIZE) {
            case 8:
                define("\102\x49\x47\x49\x4e\x54\x45\x47\x45\x52\x5f\102\101\x53\105", 31);
                define("\102\111\107\x49\x4e\124\105\107\x45\122\x5f\102\101\x53\105\x5f\x46\x55\x4c\114", 0x80000000);
                define("\x42\111\x47\111\116\x54\105\107\105\122\x5f\115\101\130\x5f\x44\x49\107\111\x54", 0x7fffffff);
                define("\x42\x49\107\111\x4e\x54\x45\107\105\122\x5f\115\123\x42", 0x40000000);
                define("\102\x49\x47\111\x4e\124\105\x47\x45\122\x5f\x4d\101\130\x31\60", 1000000000);
                define("\102\x49\107\x49\116\x54\105\107\105\122\x5f\x4d\101\130\x31\60\x5f\x4c\105\x4e", 9);
                define("\102\111\107\111\116\124\105\x47\x45\x52\137\115\101\x58\x5f\x44\111\x47\111\x54\62", pow(2, 62));
                goto Om;
            default:
                define("\102\x49\107\111\116\124\105\x47\105\122\x5f\x42\x41\123\105", 26);
                define("\x42\x49\x47\111\x4e\124\x45\x47\105\x52\x5f\x42\101\123\105\137\106\x55\x4c\114", 0x4000000);
                define("\102\x49\107\x49\116\x54\105\x47\105\122\137\x4d\101\x58\137\104\x49\107\x49\x54", 0x3ffffff);
                define("\x42\111\107\x49\x4e\124\105\107\x45\x52\x5f\115\x53\102", 0x2000000);
                define("\x42\x49\x47\x49\x4e\x54\x45\107\x45\x52\x5f\115\101\130\x31\x30", 10000000);
                define("\102\111\107\111\x4e\124\x45\x47\105\x52\137\115\101\x58\61\60\x5f\x4c\105\116", 7);
                define("\x42\x49\107\111\x4e\x54\105\107\x45\x52\x5f\x4d\101\x58\x5f\x44\111\x47\x49\124\62", pow(2, 52));
        }
        Na:
        Om:
        CM:
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                switch (true) {
                    case is_resource($gJ) && get_resource_type($gJ) == "\107\115\120\40\151\156\x74\145\x67\145\x72":
                    case is_object($gJ) && get_class($gJ) == "\x47\x4d\120":
                        $this->value = $gJ;
                        return;
                }
                UC:
                TG:
                $this->value = gmp_init(0);
                goto l7;
            case BIGINTEGER_MODE_BCMATH:
                $this->value = "\60";
                goto l7;
            default:
                $this->value = array();
        }
        Mc:
        l7:
        if (!(empty($gJ) && (abs($X6) != 256 || $gJ !== "\x30"))) {
            goto Zv;
        }
        return;
        Zv:
        switch ($X6) {
            case -256:
                if (!(ord($gJ[0]) & 0x80)) {
                    goto w9;
                }
                $gJ = ~$gJ;
                $this->is_negative = true;
                w9:
            case 256:
                switch (BIGINTEGER_MODE) {
                    case BIGINTEGER_MODE_GMP:
                        $this->value = function_exists("\x67\x6d\160\137\151\x6d\x70\x6f\x72\164") ? gmp_import($gJ) : gmp_init("\x30\x78" . bin2hex($gJ));
                        if (!$this->is_negative) {
                            goto G5;
                        }
                        $this->value = gmp_neg($this->value);
                        G5:
                        goto Dd;
                    case BIGINTEGER_MODE_BCMATH:
                        $KZ = strlen($gJ) + 3 & 0xfffffffc;
                        $gJ = str_pad($gJ, $KZ, chr(0), STR_PAD_LEFT);
                        $Tu = 0;
                        MB:
                        if (!($Tu < $KZ)) {
                            goto mO;
                        }
                        $this->value = bcmul($this->value, "\64\62\x39\x34\71\x36\67\x32\x39\66", 0);
                        $this->value = bcadd($this->value, 0x1000000 * ord($gJ[$Tu]) + (ord($gJ[$Tu + 1]) << 16 | ord($gJ[$Tu + 2]) << 8 | ord($gJ[$Tu + 3])), 0);
                        Bb:
                        $Tu += 4;
                        goto MB;
                        mO:
                        if (!$this->is_negative) {
                            goto lg;
                        }
                        $this->value = "\x2d" . $this->value;
                        lg:
                        goto Dd;
                    default:
                        ge:
                        if (!strlen($gJ)) {
                            goto wA;
                        }
                        $this->value[] = $this->_bytes2int($this->_base256_rshift($gJ, BIGINTEGER_BASE));
                        goto ge;
                        wA:
                }
                n3:
                Dd:
                if (!$this->is_negative) {
                    goto VL;
                }
                if (!(BIGINTEGER_MODE != BIGINTEGER_MODE_INTERNAL)) {
                    goto ZQ;
                }
                $this->is_negative = false;
                ZQ:
                $bJ = $this->add(new BigInteger("\x2d\61"));
                $this->value = $bJ->value;
                VL:
                goto mF;
            case 16:
            case -16:
                if (!($X6 > 0 && $gJ[0] == "\55")) {
                    goto i4;
                }
                $this->is_negative = true;
                $gJ = substr($gJ, 1);
                i4:
                $gJ = preg_replace("\x23\x5e\50\77\x3a\60\170\x29\77\50\x5b\x41\x2d\106\141\55\x66\60\55\x39\135\x2a\x29\56\x2a\43", "\x24\x31", $gJ);
                $da = false;
                if (!($X6 < 0 && hexdec($gJ[0]) >= 8)) {
                    goto CC;
                }
                $this->is_negative = $da = true;
                $gJ = bin2hex(~pack("\x48\x2a", $gJ));
                CC:
                switch (BIGINTEGER_MODE) {
                    case BIGINTEGER_MODE_GMP:
                        $bJ = $this->is_negative ? "\x2d\x30\170" . $gJ : "\x30\x78" . $gJ;
                        $this->value = gmp_init($bJ);
                        $this->is_negative = false;
                        goto TU;
                    case BIGINTEGER_MODE_BCMATH:
                        $gJ = strlen($gJ) & 1 ? "\x30" . $gJ : $gJ;
                        $bJ = new BigInteger(pack("\110\52", $gJ), 256);
                        $this->value = $this->is_negative ? "\55" . $bJ->value : $bJ->value;
                        $this->is_negative = false;
                        goto TU;
                    default:
                        $gJ = strlen($gJ) & 1 ? "\x30" . $gJ : $gJ;
                        $bJ = new BigInteger(pack("\x48\52", $gJ), 256);
                        $this->value = $bJ->value;
                }
                wS:
                TU:
                if (!$da) {
                    goto Uw;
                }
                $bJ = $this->add(new BigInteger("\x2d\61"));
                $this->value = $bJ->value;
                Uw:
                goto mF;
            case 10:
            case -10:
                $gJ = preg_replace("\x23\x28\x3f\x3c\x21\x5e\x29\x28\77\72\55\x29\x2e\x2a\x7c\x28\77\x3c\75\x5e\x7c\55\x29\x30\x2a\x7c\133\x5e\x2d\x30\55\x39\135\56\52\x23", '', $gJ);
                switch (BIGINTEGER_MODE) {
                    case BIGINTEGER_MODE_GMP:
                        $this->value = gmp_init($gJ);
                        goto Lp;
                    case BIGINTEGER_MODE_BCMATH:
                        $this->value = $gJ === "\x2d" ? "\x30" : (string) $gJ;
                        goto Lp;
                    default:
                        $bJ = new BigInteger();
                        $ly = new BigInteger();
                        $ly->value = array(BIGINTEGER_MAX10);
                        if (!($gJ[0] == "\55")) {
                            goto Bs;
                        }
                        $this->is_negative = true;
                        $gJ = substr($gJ, 1);
                        Bs:
                        $gJ = str_pad($gJ, strlen($gJ) + (BIGINTEGER_MAX10_LEN - 1) * strlen($gJ) % BIGINTEGER_MAX10_LEN, 0, STR_PAD_LEFT);
                        HB:
                        if (!strlen($gJ)) {
                            goto MZ;
                        }
                        $bJ = $bJ->multiply($ly);
                        $bJ = $bJ->add(new BigInteger($this->_int2bytes(substr($gJ, 0, BIGINTEGER_MAX10_LEN)), 256));
                        $gJ = substr($gJ, BIGINTEGER_MAX10_LEN);
                        goto HB;
                        MZ:
                        $this->value = $bJ->value;
                }
                mW:
                Lp:
                goto mF;
            case 2:
            case -2:
                if (!($X6 > 0 && $gJ[0] == "\55")) {
                    goto xo;
                }
                $this->is_negative = true;
                $gJ = substr($gJ, 1);
                xo:
                $gJ = preg_replace("\43\x5e\x28\133\x30\61\x5d\52\51\x2e\x2a\x23", "\44\61", $gJ);
                $gJ = str_pad($gJ, strlen($gJ) + 3 * strlen($gJ) % 4, 0, STR_PAD_LEFT);
                $Ga = "\x30\170";
                XF:
                if (!strlen($gJ)) {
                    goto Pw;
                }
                $Cp = substr($gJ, 0, 4);
                $Ga .= dechex(bindec($Cp));
                $gJ = substr($gJ, 4);
                goto XF;
                Pw:
                if (!$this->is_negative) {
                    goto xU;
                }
                $Ga = "\55" . $Ga;
                xU:
                $bJ = new BigInteger($Ga, 8 * $X6);
                $this->value = $bJ->value;
                $this->is_negative = $bJ->is_negative;
                goto mF;
            default:
        }
        HO:
        mF:
    }
    function BigInteger($gJ = 0, $X6 = 10)
    {
        $this->__construct($gJ, $X6);
    }
    function toBytes($tK = false)
    {
        if (!$tK) {
            goto yC;
        }
        $Dq = $this->compare(new BigInteger());
        if (!($Dq == 0)) {
            goto WD;
        }
        return $this->precision > 0 ? str_repeat(chr(0), $this->precision + 1 >> 3) : '';
        WD:
        $bJ = $Dq < 0 ? $this->add(new BigInteger(1)) : $this->copy();
        $Hu = $bJ->toBytes();
        if (!empty($Hu)) {
            goto Dy;
        }
        $Hu = chr(0);
        Dy:
        if (!(ord($Hu[0]) & 0x80)) {
            goto Gd;
        }
        $Hu = chr(0) . $Hu;
        Gd:
        return $Dq < 0 ? ~$Hu : $Hu;
        yC:
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                if (!(gmp_cmp($this->value, gmp_init(0)) == 0)) {
                    goto tz;
                }
                return $this->precision > 0 ? str_repeat(chr(0), $this->precision + 1 >> 3) : '';
                tz:
                if (function_exists("\147\x6d\x70\137\145\x78\160\x6f\162\164")) {
                    goto jY;
                }
                $bJ = gmp_strval(gmp_abs($this->value), 16);
                $bJ = strlen($bJ) & 1 ? "\60" . $bJ : $bJ;
                $bJ = pack("\x48\x2a", $bJ);
                goto Xs;
                jY:
                $bJ = gmp_export($this->value);
                Xs:
                return $this->precision > 0 ? substr(str_pad($bJ, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) : ltrim($bJ, chr(0));
            case BIGINTEGER_MODE_BCMATH:
                if (!($this->value === "\x30")) {
                    goto mX;
                }
                return $this->precision > 0 ? str_repeat(chr(0), $this->precision + 1 >> 3) : '';
                mX:
                $Rb = '';
                $UG = $this->value;
                if (!($UG[0] == "\x2d")) {
                    goto OS;
                }
                $UG = substr($UG, 1);
                OS:
                N_:
                if (!(bccomp($UG, "\x30", 0) > 0)) {
                    goto M5;
                }
                $bJ = bcmod($UG, "\x31\66\67\67\x37\62\61\66");
                $Rb = chr($bJ >> 16) . chr($bJ >> 8) . chr($bJ) . $Rb;
                $UG = bcdiv($UG, "\x31\66\x37\x37\67\62\61\66", 0);
                goto N_;
                M5:
                return $this->precision > 0 ? substr(str_pad($Rb, $this->precision >> 3, chr(0), STR_PAD_LEFT), -($this->precision >> 3)) : ltrim($Rb, chr(0));
        }
        FT:
        IL:
        if (count($this->value)) {
            goto EQ;
        }
        return $this->precision > 0 ? str_repeat(chr(0), $this->precision + 1 >> 3) : '';
        EQ:
        $UZ = $this->_int2bytes($this->value[count($this->value) - 1]);
        $bJ = $this->copy();
        $Tu = count($bJ->value) - 2;
        ct:
        if (!($Tu >= 0)) {
            goto tS;
        }
        $bJ->_base256_lshift($UZ, BIGINTEGER_BASE);
        $UZ = $UZ | str_pad($bJ->_int2bytes($bJ->value[$Tu]), strlen($UZ), chr(0), STR_PAD_LEFT);
        aJ:
        --$Tu;
        goto ct;
        tS:
        return $this->precision > 0 ? str_pad(substr($UZ, -($this->precision + 7 >> 3)), $this->precision + 7 >> 3, chr(0), STR_PAD_LEFT) : $UZ;
    }
    function toHex($tK = false)
    {
        return bin2hex($this->toBytes($tK));
    }
    function toBits($tK = false)
    {
        $EA = $this->toHex($tK);
        $JQ = '';
        $Tu = strlen($EA) - 8;
        $Fw = strlen($EA) & 7;
        L9:
        if (!($Tu >= $Fw)) {
            goto Iu;
        }
        $JQ = str_pad(decbin(hexdec(substr($EA, $Tu, 8))), 32, "\60", STR_PAD_LEFT) . $JQ;
        FJ:
        $Tu -= 8;
        goto L9;
        Iu:
        if (!$Fw) {
            goto T4;
        }
        $JQ = str_pad(decbin(hexdec(substr($EA, 0, $Fw))), 8, "\x30", STR_PAD_LEFT) . $JQ;
        T4:
        $UZ = $this->precision > 0 ? substr($JQ, -$this->precision) : ltrim($JQ, "\x30");
        if (!($tK && $this->compare(new BigInteger()) > 0 && $this->precision <= 0)) {
            goto yJ;
        }
        return "\60" . $UZ;
        yJ:
        return $UZ;
    }
    function toString()
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                return gmp_strval($this->value);
            case BIGINTEGER_MODE_BCMATH:
                if (!($this->value === "\x30")) {
                    goto TH;
                }
                return "\x30";
                TH:
                return ltrim($this->value, "\x30");
        }
        Lw:
        L2:
        if (count($this->value)) {
            goto J7;
        }
        return "\60";
        J7:
        $bJ = $this->copy();
        $bJ->is_negative = false;
        $iH = new BigInteger();
        $iH->value = array(BIGINTEGER_MAX10);
        $UZ = '';
        gb:
        if (!count($bJ->value)) {
            goto hH;
        }
        list($bJ, $No) = $bJ->divide($iH);
        $UZ = str_pad(isset($No->value[0]) ? $No->value[0] : '', BIGINTEGER_MAX10_LEN, "\60", STR_PAD_LEFT) . $UZ;
        goto gb;
        hH:
        $UZ = ltrim($UZ, "\x30");
        if (!empty($UZ)) {
            goto M0;
        }
        $UZ = "\60";
        M0:
        if (!$this->is_negative) {
            goto yV;
        }
        $UZ = "\x2d" . $UZ;
        yV:
        return $UZ;
    }
    function copy()
    {
        $bJ = new BigInteger();
        $bJ->value = $this->value;
        $bJ->is_negative = $this->is_negative;
        $bJ->precision = $this->precision;
        $bJ->bitmask = $this->bitmask;
        return $bJ;
    }
    function __toString()
    {
        return $this->toString();
    }
    function __clone()
    {
        return $this->copy();
    }
    function __sleep()
    {
        $this->hex = $this->toHex(true);
        $OX = array("\x68\145\x78");
        if (!($this->precision > 0)) {
            goto P1;
        }
        $OX[] = "\160\x72\x65\x63\151\x73\x69\157\156";
        P1:
        return $OX;
    }
    function __wakeup()
    {
        $bJ = new BigInteger($this->hex, -16);
        $this->value = $bJ->value;
        $this->is_negative = $bJ->is_negative;
        if (!($this->precision > 0)) {
            goto fI;
        }
        $this->setPrecision($this->precision);
        fI:
    }
    function __debugInfo()
    {
        $EE = array();
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $h4 = "\147\155\160";
                goto ME;
            case BIGINTEGER_MODE_BCMATH:
                $h4 = "\x62\143\155\x61\x74\x68";
                goto ME;
            case BIGINTEGER_MODE_INTERNAL:
                $h4 = "\151\156\x74\145\162\x6e\x61\x6c";
                $EE[] = PHP_INT_SIZE == 8 ? "\66\64\55\x62\x69\164" : "\63\62\x2d\x62\x69\164";
        }
        Qj:
        ME:
        if (!(BIGINTEGER_MODE != BIGINTEGER_MODE_GMP && defined("\x42\x49\x47\x49\x4e\x54\x45\107\x45\x52\x5f\117\x50\x45\x4e\123\123\x4c\137\105\116\x41\x42\x4c\105\x44"))) {
            goto wj;
        }
        $EE[] = "\x4f\160\145\156\123\x53\114";
        wj:
        if (empty($EE)) {
            goto q_;
        }
        $h4 .= "\x20\x28" . implode($EE, "\54\40") . "\51";
        q_:
        return array("\166\x61\154\165\145" => "\60\170" . $this->toHex(true), "\145\x6e\x67\x69\156\x65" => $h4);
    }
    function add($qw)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_add($this->value, $qw->value);
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $bJ = new BigInteger();
                $bJ->value = bcadd($this->value, $qw->value, 0);
                return $this->_normalize($bJ);
        }
        tV:
        Z9:
        $bJ = $this->_add($this->value, $this->is_negative, $qw->value, $qw->is_negative);
        $UZ = new BigInteger();
        $UZ->value = $bJ[BIGINTEGER_VALUE];
        $UZ->is_negative = $bJ[BIGINTEGER_SIGN];
        return $this->_normalize($UZ);
    }
    function _add($TQ, $rp, $PT, $zp)
    {
        $Tg = count($TQ);
        $yh = count($PT);
        if ($Tg == 0) {
            goto CI;
        }
        if ($yh == 0) {
            goto G7;
        }
        goto pj;
        CI:
        return array(BIGINTEGER_VALUE => $PT, BIGINTEGER_SIGN => $zp);
        goto pj;
        G7:
        return array(BIGINTEGER_VALUE => $TQ, BIGINTEGER_SIGN => $rp);
        pj:
        if (!($rp != $zp)) {
            goto Bd;
        }
        if (!($TQ == $PT)) {
            goto Qy;
        }
        return array(BIGINTEGER_VALUE => array(), BIGINTEGER_SIGN => false);
        Qy:
        $bJ = $this->_subtract($TQ, false, $PT, false);
        $bJ[BIGINTEGER_SIGN] = $this->_compare($TQ, false, $PT, false) > 0 ? $rp : $zp;
        return $bJ;
        Bd:
        if ($Tg < $yh) {
            goto lL;
        }
        $jS = $yh;
        $Rb = $TQ;
        goto TL;
        lL:
        $jS = $Tg;
        $Rb = $PT;
        TL:
        $Rb[count($Rb)] = 0;
        $Q1 = 0;
        $Tu = 0;
        $i9 = 1;
        cq:
        if (!($i9 < $jS)) {
            goto JR;
        }
        $qu = $TQ[$i9] * BIGINTEGER_BASE_FULL + $TQ[$Tu] + $PT[$i9] * BIGINTEGER_BASE_FULL + $PT[$Tu] + $Q1;
        $Q1 = $qu >= BIGINTEGER_MAX_DIGIT2;
        $qu = $Q1 ? $qu - BIGINTEGER_MAX_DIGIT2 : $qu;
        $bJ = BIGINTEGER_BASE === 26 ? intval($qu / 0x4000000) : $qu >> 31;
        $Rb[$Tu] = (int) ($qu - BIGINTEGER_BASE_FULL * $bJ);
        $Rb[$i9] = $bJ;
        YN:
        $Tu += 2;
        $i9 += 2;
        goto cq;
        JR:
        if (!($i9 == $jS)) {
            goto h1;
        }
        $qu = $TQ[$Tu] + $PT[$Tu] + $Q1;
        $Q1 = $qu >= BIGINTEGER_BASE_FULL;
        $Rb[$Tu] = $Q1 ? $qu - BIGINTEGER_BASE_FULL : $qu;
        ++$Tu;
        h1:
        if (!$Q1) {
            goto CU;
        }
        Dm:
        if (!($Rb[$Tu] == BIGINTEGER_MAX_DIGIT)) {
            goto bj;
        }
        $Rb[$Tu] = 0;
        uJ:
        ++$Tu;
        goto Dm;
        bj:
        ++$Rb[$Tu];
        CU:
        return array(BIGINTEGER_VALUE => $this->_trim($Rb), BIGINTEGER_SIGN => $rp);
    }
    function subtract($qw)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_sub($this->value, $qw->value);
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $bJ = new BigInteger();
                $bJ->value = bcsub($this->value, $qw->value, 0);
                return $this->_normalize($bJ);
        }
        Yr:
        sV:
        $bJ = $this->_subtract($this->value, $this->is_negative, $qw->value, $qw->is_negative);
        $UZ = new BigInteger();
        $UZ->value = $bJ[BIGINTEGER_VALUE];
        $UZ->is_negative = $bJ[BIGINTEGER_SIGN];
        return $this->_normalize($UZ);
    }
    function _subtract($TQ, $rp, $PT, $zp)
    {
        $Tg = count($TQ);
        $yh = count($PT);
        if ($Tg == 0) {
            goto df;
        }
        if ($yh == 0) {
            goto tu;
        }
        goto jP;
        df:
        return array(BIGINTEGER_VALUE => $PT, BIGINTEGER_SIGN => !$zp);
        goto jP;
        tu:
        return array(BIGINTEGER_VALUE => $TQ, BIGINTEGER_SIGN => $rp);
        jP:
        if (!($rp != $zp)) {
            goto QQ;
        }
        $bJ = $this->_add($TQ, false, $PT, false);
        $bJ[BIGINTEGER_SIGN] = $rp;
        return $bJ;
        QQ:
        $R3 = $this->_compare($TQ, $rp, $PT, $zp);
        if ($R3) {
            goto U_;
        }
        return array(BIGINTEGER_VALUE => array(), BIGINTEGER_SIGN => false);
        U_:
        if (!(!$rp && $R3 < 0 || $rp && $R3 > 0)) {
            goto Q9;
        }
        $bJ = $TQ;
        $TQ = $PT;
        $PT = $bJ;
        $rp = !$rp;
        $Tg = count($TQ);
        $yh = count($PT);
        Q9:
        $Q1 = 0;
        $Tu = 0;
        $i9 = 1;
        Mk:
        if (!($i9 < $yh)) {
            goto eC;
        }
        $qu = $TQ[$i9] * BIGINTEGER_BASE_FULL + $TQ[$Tu] - $PT[$i9] * BIGINTEGER_BASE_FULL - $PT[$Tu] - $Q1;
        $Q1 = $qu < 0;
        $qu = $Q1 ? $qu + BIGINTEGER_MAX_DIGIT2 : $qu;
        $bJ = BIGINTEGER_BASE === 26 ? intval($qu / 0x4000000) : $qu >> 31;
        $TQ[$Tu] = (int) ($qu - BIGINTEGER_BASE_FULL * $bJ);
        $TQ[$i9] = $bJ;
        M6:
        $Tu += 2;
        $i9 += 2;
        goto Mk;
        eC:
        if (!($i9 == $yh)) {
            goto wH;
        }
        $qu = $TQ[$Tu] - $PT[$Tu] - $Q1;
        $Q1 = $qu < 0;
        $TQ[$Tu] = $Q1 ? $qu + BIGINTEGER_BASE_FULL : $qu;
        ++$Tu;
        wH:
        if (!$Q1) {
            goto Lg;
        }
        ZP:
        if ($TQ[$Tu]) {
            goto Ng;
        }
        $TQ[$Tu] = BIGINTEGER_MAX_DIGIT;
        Mn:
        ++$Tu;
        goto ZP;
        Ng:
        --$TQ[$Tu];
        Lg:
        return array(BIGINTEGER_VALUE => $this->_trim($TQ), BIGINTEGER_SIGN => $rp);
    }
    function multiply($gJ)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_mul($this->value, $gJ->value);
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $bJ = new BigInteger();
                $bJ->value = bcmul($this->value, $gJ->value, 0);
                return $this->_normalize($bJ);
        }
        yA:
        jo:
        $bJ = $this->_multiply($this->value, $this->is_negative, $gJ->value, $gJ->is_negative);
        $d2 = new BigInteger();
        $d2->value = $bJ[BIGINTEGER_VALUE];
        $d2->is_negative = $bJ[BIGINTEGER_SIGN];
        return $this->_normalize($d2);
    }
    function _multiply($TQ, $rp, $PT, $zp)
    {
        $SN = count($TQ);
        $An = count($PT);
        if (!(!$SN || !$An)) {
            goto PI;
        }
        return array(BIGINTEGER_VALUE => array(), BIGINTEGER_SIGN => false);
        PI:
        return array(BIGINTEGER_VALUE => min($SN, $An) < 2 * BIGINTEGER_KARATSUBA_CUTOFF ? $this->_trim($this->_regularMultiply($TQ, $PT)) : $this->_trim($this->_karatsuba($TQ, $PT)), BIGINTEGER_SIGN => $rp != $zp);
    }
    function _regularMultiply($TQ, $PT)
    {
        $SN = count($TQ);
        $An = count($PT);
        if (!(!$SN || !$An)) {
            goto XT;
        }
        return array();
        XT:
        if (!($SN < $An)) {
            goto g5;
        }
        $bJ = $TQ;
        $TQ = $PT;
        $PT = $bJ;
        $SN = count($TQ);
        $An = count($PT);
        g5:
        $b4 = $this->_array_repeat(0, $SN + $An);
        $Q1 = 0;
        $i9 = 0;
        qR:
        if (!($i9 < $SN)) {
            goto iB;
        }
        $bJ = $TQ[$i9] * $PT[0] + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $b4[$i9] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        v2:
        ++$i9;
        goto qR;
        iB:
        $b4[$i9] = $Q1;
        $Tu = 1;
        sl:
        if (!($Tu < $An)) {
            goto mZ;
        }
        $Q1 = 0;
        $i9 = 0;
        $yt = $Tu;
        QK:
        if (!($i9 < $SN)) {
            goto ib;
        }
        $bJ = $b4[$yt] + $TQ[$i9] * $PT[$Tu] + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $b4[$yt] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        b4:
        ++$i9;
        ++$yt;
        goto QK;
        ib:
        $b4[$yt] = $Q1;
        Dq:
        ++$Tu;
        goto sl;
        mZ:
        return $b4;
    }
    function _karatsuba($TQ, $PT)
    {
        $qa = min(count($TQ) >> 1, count($PT) >> 1);
        if (!($qa < BIGINTEGER_KARATSUBA_CUTOFF)) {
            goto uv;
        }
        return $this->_regularMultiply($TQ, $PT);
        uv:
        $Us = array_slice($TQ, $qa);
        $cp = array_slice($TQ, 0, $qa);
        $l5 = array_slice($PT, $qa);
        $hg = array_slice($PT, 0, $qa);
        $Ae = $this->_karatsuba($Us, $l5);
        $C5 = $this->_karatsuba($cp, $hg);
        $Ec = $this->_add($Us, false, $cp, false);
        $bJ = $this->_add($l5, false, $hg, false);
        $Ec = $this->_karatsuba($Ec[BIGINTEGER_VALUE], $bJ[BIGINTEGER_VALUE]);
        $bJ = $this->_add($Ae, false, $C5, false);
        $Ec = $this->_subtract($Ec, false, $bJ[BIGINTEGER_VALUE], false);
        $Ae = array_merge(array_fill(0, 2 * $qa, 0), $Ae);
        $Ec[BIGINTEGER_VALUE] = array_merge(array_fill(0, $qa, 0), $Ec[BIGINTEGER_VALUE]);
        $i8 = $this->_add($Ae, false, $Ec[BIGINTEGER_VALUE], $Ec[BIGINTEGER_SIGN]);
        $i8 = $this->_add($i8[BIGINTEGER_VALUE], $i8[BIGINTEGER_SIGN], $C5, false);
        return $i8[BIGINTEGER_VALUE];
    }
    function _square($gJ = false)
    {
        return count($gJ) < 2 * BIGINTEGER_KARATSUBA_CUTOFF ? $this->_trim($this->_baseSquare($gJ)) : $this->_trim($this->_karatsubaSquare($gJ));
    }
    function _baseSquare($Rb)
    {
        if (!empty($Rb)) {
            goto HU;
        }
        return array();
        HU:
        $dV = $this->_array_repeat(0, 2 * count($Rb));
        $Tu = 0;
        $TK = count($Rb) - 1;
        ug:
        if (!($Tu <= $TK)) {
            goto o0;
        }
        $Ie = $Tu << 1;
        $bJ = $dV[$Ie] + $Rb[$Tu] * $Rb[$Tu];
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $dV[$Ie] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        $i9 = $Tu + 1;
        $yt = $Ie + 1;
        eW:
        if (!($i9 <= $TK)) {
            goto Nj;
        }
        $bJ = $dV[$yt] + 2 * $Rb[$i9] * $Rb[$Tu] + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $dV[$yt] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        JD:
        ++$i9;
        ++$yt;
        goto eW;
        Nj:
        $dV[$Tu + $TK + 1] = $Q1;
        LR:
        ++$Tu;
        goto ug;
        o0:
        return $dV;
    }
    function _karatsubaSquare($Rb)
    {
        $qa = count($Rb) >> 1;
        if (!($qa < BIGINTEGER_KARATSUBA_CUTOFF)) {
            goto oj;
        }
        return $this->_baseSquare($Rb);
        oj:
        $Us = array_slice($Rb, $qa);
        $cp = array_slice($Rb, 0, $qa);
        $Ae = $this->_karatsubaSquare($Us);
        $C5 = $this->_karatsubaSquare($cp);
        $Ec = $this->_add($Us, false, $cp, false);
        $Ec = $this->_karatsubaSquare($Ec[BIGINTEGER_VALUE]);
        $bJ = $this->_add($Ae, false, $C5, false);
        $Ec = $this->_subtract($Ec, false, $bJ[BIGINTEGER_VALUE], false);
        $Ae = array_merge(array_fill(0, 2 * $qa, 0), $Ae);
        $Ec[BIGINTEGER_VALUE] = array_merge(array_fill(0, $qa, 0), $Ec[BIGINTEGER_VALUE]);
        $pH = $this->_add($Ae, false, $Ec[BIGINTEGER_VALUE], $Ec[BIGINTEGER_SIGN]);
        $pH = $this->_add($pH[BIGINTEGER_VALUE], $pH[BIGINTEGER_SIGN], $C5, false);
        return $pH[BIGINTEGER_VALUE];
    }
    function divide($qw)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $XQ = new BigInteger();
                $bt = new BigInteger();
                list($XQ->value, $bt->value) = gmp_div_qr($this->value, $qw->value);
                if (!(gmp_sign($bt->value) < 0)) {
                    goto kz;
                }
                $bt->value = gmp_add($bt->value, gmp_abs($qw->value));
                kz:
                return array($this->_normalize($XQ), $this->_normalize($bt));
            case BIGINTEGER_MODE_BCMATH:
                $XQ = new BigInteger();
                $bt = new BigInteger();
                $XQ->value = bcdiv($this->value, $qw->value, 0);
                $bt->value = bcmod($this->value, $qw->value);
                if (!($bt->value[0] == "\x2d")) {
                    goto Vh;
                }
                $bt->value = bcadd($bt->value, $qw->value[0] == "\55" ? substr($qw->value, 1) : $qw->value, 0);
                Vh:
                return array($this->_normalize($XQ), $this->_normalize($bt));
        }
        rE:
        hN:
        if (!(count($qw->value) == 1)) {
            goto Un;
        }
        list($E8, $zZ) = $this->_divide_digit($this->value, $qw->value[0]);
        $XQ = new BigInteger();
        $bt = new BigInteger();
        $XQ->value = $E8;
        $bt->value = array($zZ);
        $XQ->is_negative = $this->is_negative != $qw->is_negative;
        return array($this->_normalize($XQ), $this->_normalize($bt));
        Un:
        static $SJ;
        if (isset($SJ)) {
            goto qc;
        }
        $SJ = new BigInteger();
        qc:
        $gJ = $this->copy();
        $qw = $qw->copy();
        $rX = $gJ->is_negative;
        $FY = $qw->is_negative;
        $gJ->is_negative = $qw->is_negative = false;
        $R3 = $gJ->compare($qw);
        if ($R3) {
            goto RZ;
        }
        $bJ = new BigInteger();
        $bJ->value = array(1);
        $bJ->is_negative = $rX != $FY;
        return array($this->_normalize($bJ), $this->_normalize(new BigInteger()));
        RZ:
        if (!($R3 < 0)) {
            goto Vy;
        }
        if (!$rX) {
            goto Cr;
        }
        $gJ = $qw->subtract($gJ);
        Cr:
        return array($this->_normalize(new BigInteger()), $this->_normalize($gJ));
        Vy:
        $Ty = $qw->value[count($qw->value) - 1];
        $YL = 0;
        Kq:
        if ($Ty & BIGINTEGER_MSB) {
            goto eL;
        }
        $Ty <<= 1;
        Ok:
        ++$YL;
        goto Kq;
        eL:
        $gJ->_lshift($YL);
        $qw->_lshift($YL);
        $PT =& $qw->value;
        $Zi = count($gJ->value) - 1;
        $q6 = count($qw->value) - 1;
        $XQ = new BigInteger();
        $yA =& $XQ->value;
        $yA = $this->_array_repeat(0, $Zi - $q6 + 1);
        static $bJ, $VZ, $Dw;
        if (isset($bJ)) {
            goto Ae;
        }
        $bJ = new BigInteger();
        $VZ = new BigInteger();
        $Dw = new BigInteger();
        Ae:
        $W5 =& $bJ->value;
        $AS =& $Dw->value;
        $W5 = array_merge($this->_array_repeat(0, $Zi - $q6), $PT);
        mJ:
        if (!($gJ->compare($bJ) >= 0)) {
            goto kb;
        }
        ++$yA[$Zi - $q6];
        $gJ = $gJ->subtract($bJ);
        $Zi = count($gJ->value) - 1;
        goto mJ;
        kb:
        $Tu = $Zi;
        aj:
        if (!($Tu >= $q6 + 1)) {
            goto Yx;
        }
        $TQ =& $gJ->value;
        $K3 = array(isset($TQ[$Tu]) ? $TQ[$Tu] : 0, isset($TQ[$Tu - 1]) ? $TQ[$Tu - 1] : 0, isset($TQ[$Tu - 2]) ? $TQ[$Tu - 2] : 0);
        $xp = array($PT[$q6], $q6 > 0 ? $PT[$q6 - 1] : 0);
        $Rk = $Tu - $q6 - 1;
        if ($K3[0] == $xp[0]) {
            goto UL;
        }
        $yA[$Rk] = $this->_safe_divide($K3[0] * BIGINTEGER_BASE_FULL + $K3[1], $xp[0]);
        goto oh;
        UL:
        $yA[$Rk] = BIGINTEGER_MAX_DIGIT;
        oh:
        $W5 = array($xp[1], $xp[0]);
        $VZ->value = array($yA[$Rk]);
        $VZ = $VZ->multiply($bJ);
        $AS = array($K3[2], $K3[1], $K3[0]);
        s5:
        if (!($VZ->compare($Dw) > 0)) {
            goto qx;
        }
        --$yA[$Rk];
        $VZ->value = array($yA[$Rk]);
        $VZ = $VZ->multiply($bJ);
        goto s5;
        qx:
        $SD = $this->_array_repeat(0, $Rk);
        $W5 = array($yA[$Rk]);
        $bJ = $bJ->multiply($qw);
        $W5 =& $bJ->value;
        $W5 = array_merge($SD, $W5);
        $gJ = $gJ->subtract($bJ);
        if (!($gJ->compare($SJ) < 0)) {
            goto pZ;
        }
        $W5 = array_merge($SD, $PT);
        $gJ = $gJ->add($bJ);
        --$yA[$Rk];
        pZ:
        $Zi = count($TQ) - 1;
        Am:
        --$Tu;
        goto aj;
        Yx:
        $gJ->_rshift($YL);
        $XQ->is_negative = $rX != $FY;
        if (!$rX) {
            goto BN;
        }
        $qw->_rshift($YL);
        $gJ = $qw->subtract($gJ);
        BN:
        return array($this->_normalize($XQ), $this->_normalize($gJ));
    }
    function _divide_digit($bF, $iH)
    {
        $Q1 = 0;
        $UZ = array();
        $Tu = count($bF) - 1;
        GJ:
        if (!($Tu >= 0)) {
            goto PC;
        }
        $bJ = BIGINTEGER_BASE_FULL * $Q1 + $bF[$Tu];
        $UZ[$Tu] = $this->_safe_divide($bJ, $iH);
        $Q1 = (int) ($bJ - $iH * $UZ[$Tu]);
        OI:
        --$Tu;
        goto GJ;
        PC:
        return array($UZ, $Q1);
    }
    function modPow($LY, $c8)
    {
        $c8 = $this->bitmask !== false && $this->bitmask->compare($c8) < 0 ? $this->bitmask : $c8->abs();
        if (!($LY->compare(new BigInteger()) < 0)) {
            goto aR;
        }
        $LY = $LY->abs();
        $bJ = $this->modInverse($c8);
        if (!($bJ === false)) {
            goto Vb;
        }
        return false;
        Vb:
        return $this->_normalize($bJ->modPow($LY, $c8));
        aR:
        if (!(BIGINTEGER_MODE == BIGINTEGER_MODE_GMP)) {
            goto Ox;
        }
        $bJ = new BigInteger();
        $bJ->value = gmp_powm($this->value, $LY->value, $c8->value);
        return $this->_normalize($bJ);
        Ox:
        if (!($this->compare(new BigInteger()) < 0 || $this->compare($c8) > 0)) {
            goto T8;
        }
        list(, $bJ) = $this->divide($c8);
        return $bJ->modPow($LY, $c8);
        T8:
        if (!defined("\102\111\x47\111\116\124\x45\107\105\x52\x5f\117\120\x45\116\123\x53\114\x5f\105\x4e\x41\102\114\x45\x44")) {
            goto QE;
        }
        $sU = array("\x6d\x6f\144\x75\154\x75\x73" => $c8->toBytes(true), "\x70\165\x62\x6c\151\143\105\x78\160\x6f\156\x65\156\164" => $LY->toBytes(true));
        $sU = array("\x6d\x6f\x64\x75\154\165\x73" => pack("\103\x61\52\x61\x2a", 2, $this->_encodeASN1Length(strlen($sU["\155\157\x64\165\x6c\165\163"])), $sU["\x6d\157\x64\x75\154\165\x73"]), "\160\165\x62\154\151\143\105\x78\x70\x6f\156\x65\156\164" => pack("\x43\141\x2a\x61\x2a", 2, $this->_encodeASN1Length(strlen($sU["\160\x75\x62\154\151\143\x45\x78\160\x6f\156\x65\156\x74"])), $sU["\x70\x75\142\x6c\151\143\105\170\x70\x6f\156\x65\x6e\x74"]));
        $zb = pack("\103\141\x2a\141\52\x61\52", 48, $this->_encodeASN1Length(strlen($sU["\155\x6f\144\165\154\x75\163"]) + strlen($sU["\x70\x75\x62\154\151\x63\x45\170\x70\x6f\x6e\x65\156\164"])), $sU["\x6d\x6f\x64\x75\154\165\163"], $sU["\x70\x75\x62\154\151\x63\x45\x78\x70\x6f\156\145\156\164"]);
        $dD = pack("\110\x2a", "\x33\60\60\x64\60\x36\60\71\x32\141\70\66\x34\x38\70\66\x66\x37\x30\144\x30\61\x30\61\x30\x31\60\x35\x30\60");
        $zb = chr(0) . $zb;
        $zb = chr(3) . $this->_encodeASN1Length(strlen($zb)) . $zb;
        $Fk = pack("\103\x61\x2a\141\x2a", 48, $this->_encodeASN1Length(strlen($dD . $zb)), $dD . $zb);
        $zb = "\55\55\x2d\x2d\x2d\x42\105\x47\111\x4e\x20\120\125\x42\114\111\x43\40\113\105\x59\55\x2d\55\x2d\55\15\xa" . chunk_split(base64_encode($Fk)) . "\55\55\x2d\55\55\105\x4e\104\x20\x50\125\102\x4c\x49\x43\x20\x4b\x45\131\55\x2d\x2d\x2d\x2d";
        $cG = str_pad($this->toBytes(), strlen($c8->toBytes(true)) - 1, "\x0", STR_PAD_LEFT);
        if (!openssl_public_encrypt($cG, $UZ, $zb, OPENSSL_NO_PADDING)) {
            goto SC;
        }
        return new BigInteger($UZ, 256);
        SC:
        QE:
        if (!(BIGINTEGER_MODE == BIGINTEGER_MODE_BCMATH)) {
            goto vA;
        }
        $bJ = new BigInteger();
        $bJ->value = bcpowmod($this->value, $LY->value, $c8->value, 0);
        return $this->_normalize($bJ);
        vA:
        if (!empty($LY->value)) {
            goto Q5;
        }
        $bJ = new BigInteger();
        $bJ->value = array(1);
        return $this->_normalize($bJ);
        Q5:
        if (!($LY->value == array(1))) {
            goto CK;
        }
        list(, $bJ) = $this->divide($c8);
        return $this->_normalize($bJ);
        CK:
        if (!($LY->value == array(2))) {
            goto KK;
        }
        $bJ = new BigInteger();
        $bJ->value = $this->_square($this->value);
        list(, $bJ) = $bJ->divide($c8);
        return $this->_normalize($bJ);
        KK:
        return $this->_normalize($this->_slidingWindow($LY, $c8, BIGINTEGER_BARRETT));
        if (!($c8->value[0] & 1)) {
            goto V5;
        }
        return $this->_normalize($this->_slidingWindow($LY, $c8, BIGINTEGER_MONTGOMERY));
        V5:
        $Tu = 0;
        dZ:
        if (!($Tu < count($c8->value))) {
            goto l0;
        }
        if (!$c8->value[$Tu]) {
            goto XW;
        }
        $bJ = decbin($c8->value[$Tu]);
        $i9 = strlen($bJ) - strrpos($bJ, "\x31") - 1;
        $i9 += 26 * $Tu;
        goto l0;
        XW:
        rq:
        ++$Tu;
        goto dZ;
        l0:
        $iA = $c8->copy();
        $iA->_rshift($i9);
        $P2 = new BigInteger();
        $P2->value = array(1);
        $P2->_lshift($i9);
        $sG = $iA->value != array(1) ? $this->_slidingWindow($LY, $iA, BIGINTEGER_MONTGOMERY) : new BigInteger();
        $ZZ = $this->_slidingWindow($LY, $P2, BIGINTEGER_POWEROF2);
        $l5 = $P2->modInverse($iA);
        $XY = $iA->modInverse($P2);
        $UZ = $sG->multiply($P2);
        $UZ = $UZ->multiply($l5);
        $bJ = $ZZ->multiply($iA);
        $bJ = $bJ->multiply($XY);
        $UZ = $UZ->add($bJ);
        list(, $UZ) = $UZ->divide($c8);
        return $this->_normalize($UZ);
    }
    function powMod($LY, $c8)
    {
        return $this->modPow($LY, $c8);
    }
    function _slidingWindow($LY, $c8, $wO)
    {
        static $E7 = array(7, 25, 81, 241, 673, 1793);
        $sY = $LY->value;
        $nP = count($sY) - 1;
        $Rg = decbin($sY[$nP]);
        $Tu = $nP - 1;
        k5:
        if (!($Tu >= 0)) {
            goto KO;
        }
        $Rg .= str_pad(decbin($sY[$Tu]), BIGINTEGER_BASE, "\60", STR_PAD_LEFT);
        Hv:
        --$Tu;
        goto k5;
        KO:
        $nP = strlen($Rg);
        $Tu = 0;
        $WA = 1;
        Rg:
        if (!($Tu < count($E7) && $nP > $E7[$Tu])) {
            goto xR;
        }
        ng:
        ++$WA;
        ++$Tu;
        goto Rg;
        xR:
        $L2 = $c8->value;
        $j5 = array();
        $j5[1] = $this->_prepareReduce($this->value, $L2, $wO);
        $j5[2] = $this->_squareReduce($j5[1], $L2, $wO);
        $bJ = 1 << $WA - 1;
        $Tu = 1;
        JO:
        if (!($Tu < $bJ)) {
            goto u3;
        }
        $Ie = $Tu << 1;
        $j5[$Ie + 1] = $this->_multiplyReduce($j5[$Ie - 1], $j5[2], $L2, $wO);
        AJ:
        ++$Tu;
        goto JO;
        u3:
        $UZ = array(1);
        $UZ = $this->_prepareReduce($UZ, $L2, $wO);
        $Tu = 0;
        HC:
        if (!($Tu < $nP)) {
            goto Yh;
        }
        if (!$Rg[$Tu]) {
            goto rP;
        }
        $i9 = $WA - 1;
        eq:
        if (!($i9 > 0)) {
            goto rO;
        }
        if (empty($Rg[$Tu + $i9])) {
            goto YC;
        }
        goto rO;
        YC:
        qJ:
        --$i9;
        goto eq;
        rO:
        $yt = 0;
        Dc:
        if (!($yt <= $i9)) {
            goto q0;
        }
        $UZ = $this->_squareReduce($UZ, $L2, $wO);
        Q6:
        ++$yt;
        goto Dc;
        q0:
        $UZ = $this->_multiplyReduce($UZ, $j5[bindec(substr($Rg, $Tu, $i9 + 1))], $L2, $wO);
        $Tu += $i9 + 1;
        goto eE;
        rP:
        $UZ = $this->_squareReduce($UZ, $L2, $wO);
        ++$Tu;
        eE:
        EM:
        goto HC;
        Yh:
        $bJ = new BigInteger();
        $bJ->value = $this->_reduce($UZ, $L2, $wO);
        return $bJ;
    }
    function _reduce($gJ, $c8, $wO)
    {
        switch ($wO) {
            case BIGINTEGER_MONTGOMERY:
                return $this->_montgomery($gJ, $c8);
            case BIGINTEGER_BARRETT:
                return $this->_barrett($gJ, $c8);
            case BIGINTEGER_POWEROF2:
                $VZ = new BigInteger();
                $VZ->value = $gJ;
                $Dw = new BigInteger();
                $Dw->value = $c8;
                return $gJ->_mod2($c8);
            case BIGINTEGER_CLASSIC:
                $VZ = new BigInteger();
                $VZ->value = $gJ;
                $Dw = new BigInteger();
                $Dw->value = $c8;
                list(, $bJ) = $VZ->divide($Dw);
                return $bJ->value;
            case BIGINTEGER_NONE:
                return $gJ;
            default:
        }
        hL:
        ba:
    }
    function _prepareReduce($gJ, $c8, $wO)
    {
        if (!($wO == BIGINTEGER_MONTGOMERY)) {
            goto RJ;
        }
        return $this->_prepMontgomery($gJ, $c8);
        RJ:
        return $this->_reduce($gJ, $c8, $wO);
    }
    function _multiplyReduce($gJ, $qw, $c8, $wO)
    {
        if (!($wO == BIGINTEGER_MONTGOMERY)) {
            goto dY;
        }
        return $this->_montgomeryMultiply($gJ, $qw, $c8);
        dY:
        $bJ = $this->_multiply($gJ, false, $qw, false);
        return $this->_reduce($bJ[BIGINTEGER_VALUE], $c8, $wO);
    }
    function _squareReduce($gJ, $c8, $wO)
    {
        if (!($wO == BIGINTEGER_MONTGOMERY)) {
            goto Rl;
        }
        return $this->_montgomeryMultiply($gJ, $gJ, $c8);
        Rl:
        return $this->_reduce($this->_square($gJ), $c8, $wO);
    }
    function _mod2($c8)
    {
        $bJ = new BigInteger();
        $bJ->value = array(1);
        return $this->bitwise_and($c8->subtract($bJ));
    }
    function _barrett($c8, $qa)
    {
        static $Vx = array(BIGINTEGER_VARIABLE => array(), BIGINTEGER_DATA => array());
        $ef = count($qa);
        if (!(count($c8) > 2 * $ef)) {
            goto Dw;
        }
        $VZ = new BigInteger();
        $Dw = new BigInteger();
        $VZ->value = $c8;
        $Dw->value = $qa;
        list(, $bJ) = $VZ->divide($Dw);
        return $bJ->value;
        Dw:
        if (!($ef < 5)) {
            goto o4;
        }
        return $this->_regularBarrett($c8, $qa);
        o4:
        if (($vt = array_search($qa, $Vx[BIGINTEGER_VARIABLE])) === false) {
            goto UY;
        }
        extract($Vx[BIGINTEGER_DATA][$vt]);
        goto yx;
        UY:
        $vt = count($Vx[BIGINTEGER_VARIABLE]);
        $Vx[BIGINTEGER_VARIABLE][] = $qa;
        $VZ = new BigInteger();
        $pf =& $VZ->value;
        $pf = $this->_array_repeat(0, $ef + ($ef >> 1));
        $pf[] = 1;
        $Dw = new BigInteger();
        $Dw->value = $qa;
        list($p4, $P7) = $VZ->divide($Dw);
        $p4 = $p4->value;
        $P7 = $P7->value;
        $Vx[BIGINTEGER_DATA][] = array("\x75" => $p4, "\155\x31" => $P7);
        yx:
        $Ma = $ef + ($ef >> 1);
        $W0 = array_slice($c8, 0, $Ma);
        $Iv = array_slice($c8, $Ma);
        $W0 = $this->_trim($W0);
        $bJ = $this->_multiply($Iv, false, $P7, false);
        $c8 = $this->_add($W0, false, $bJ[BIGINTEGER_VALUE], false);
        if (!($ef & 1)) {
            goto Jh;
        }
        return $this->_regularBarrett($c8[BIGINTEGER_VALUE], $qa);
        Jh:
        $bJ = array_slice($c8[BIGINTEGER_VALUE], $ef - 1);
        $bJ = $this->_multiply($bJ, false, $p4, false);
        $bJ = array_slice($bJ[BIGINTEGER_VALUE], ($ef >> 1) + 1);
        $bJ = $this->_multiply($bJ, false, $qa, false);
        $UZ = $this->_subtract($c8[BIGINTEGER_VALUE], false, $bJ[BIGINTEGER_VALUE], false);
        qg:
        if (!($this->_compare($UZ[BIGINTEGER_VALUE], $UZ[BIGINTEGER_SIGN], $qa, false) >= 0)) {
            goto t4;
        }
        $UZ = $this->_subtract($UZ[BIGINTEGER_VALUE], $UZ[BIGINTEGER_SIGN], $qa, false);
        goto qg;
        t4:
        return $UZ[BIGINTEGER_VALUE];
    }
    function _regularBarrett($gJ, $c8)
    {
        static $Vx = array(BIGINTEGER_VARIABLE => array(), BIGINTEGER_DATA => array());
        $xg = count($c8);
        if (!(count($gJ) > 2 * $xg)) {
            goto Hh;
        }
        $VZ = new BigInteger();
        $Dw = new BigInteger();
        $VZ->value = $gJ;
        $Dw->value = $c8;
        list(, $bJ) = $VZ->divide($Dw);
        return $bJ->value;
        Hh:
        if (!(($vt = array_search($c8, $Vx[BIGINTEGER_VARIABLE])) === false)) {
            goto r0;
        }
        $vt = count($Vx[BIGINTEGER_VARIABLE]);
        $Vx[BIGINTEGER_VARIABLE][] = $c8;
        $VZ = new BigInteger();
        $pf =& $VZ->value;
        $pf = $this->_array_repeat(0, 2 * $xg);
        $pf[] = 1;
        $Dw = new BigInteger();
        $Dw->value = $c8;
        list($bJ, ) = $VZ->divide($Dw);
        $Vx[BIGINTEGER_DATA][] = $bJ->value;
        r0:
        $bJ = array_slice($gJ, $xg - 1);
        $bJ = $this->_multiply($bJ, false, $Vx[BIGINTEGER_DATA][$vt], false);
        $bJ = array_slice($bJ[BIGINTEGER_VALUE], $xg + 1);
        $UZ = array_slice($gJ, 0, $xg + 1);
        $bJ = $this->_multiplyLower($bJ, false, $c8, false, $xg + 1);
        if (!($this->_compare($UZ, false, $bJ[BIGINTEGER_VALUE], $bJ[BIGINTEGER_SIGN]) < 0)) {
            goto P7;
        }
        $Jk = $this->_array_repeat(0, $xg + 1);
        $Jk[count($Jk)] = 1;
        $UZ = $this->_add($UZ, false, $Jk, false);
        $UZ = $UZ[BIGINTEGER_VALUE];
        P7:
        $UZ = $this->_subtract($UZ, false, $bJ[BIGINTEGER_VALUE], $bJ[BIGINTEGER_SIGN]);
        pS:
        if (!($this->_compare($UZ[BIGINTEGER_VALUE], $UZ[BIGINTEGER_SIGN], $c8, false) > 0)) {
            goto K8;
        }
        $UZ = $this->_subtract($UZ[BIGINTEGER_VALUE], $UZ[BIGINTEGER_SIGN], $c8, false);
        goto pS;
        K8:
        return $UZ[BIGINTEGER_VALUE];
    }
    function _multiplyLower($TQ, $rp, $PT, $zp, $Vg)
    {
        $SN = count($TQ);
        $An = count($PT);
        if (!(!$SN || !$An)) {
            goto EU;
        }
        return array(BIGINTEGER_VALUE => array(), BIGINTEGER_SIGN => false);
        EU:
        if (!($SN < $An)) {
            goto Qb;
        }
        $bJ = $TQ;
        $TQ = $PT;
        $PT = $bJ;
        $SN = count($TQ);
        $An = count($PT);
        Qb:
        $b4 = $this->_array_repeat(0, $SN + $An);
        $Q1 = 0;
        $i9 = 0;
        tK:
        if (!($i9 < $SN)) {
            goto mH;
        }
        $bJ = $TQ[$i9] * $PT[0] + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $b4[$i9] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        R3:
        ++$i9;
        goto tK;
        mH:
        if (!($i9 < $Vg)) {
            goto BQ;
        }
        $b4[$i9] = $Q1;
        BQ:
        $Tu = 1;
        Bj:
        if (!($Tu < $An)) {
            goto W4;
        }
        $Q1 = 0;
        $i9 = 0;
        $yt = $Tu;
        DM:
        if (!($i9 < $SN && $yt < $Vg)) {
            goto N3;
        }
        $bJ = $b4[$yt] + $TQ[$i9] * $PT[$Tu] + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $b4[$yt] = (int) ($bJ - BIGINTEGER_BASE_FULL * $Q1);
        tc:
        ++$i9;
        ++$yt;
        goto DM;
        N3:
        if (!($yt < $Vg)) {
            goto Pz;
        }
        $b4[$yt] = $Q1;
        Pz:
        UA:
        ++$Tu;
        goto Bj;
        W4:
        return array(BIGINTEGER_VALUE => $this->_trim($b4), BIGINTEGER_SIGN => $rp != $zp);
    }
    function _montgomery($gJ, $c8)
    {
        static $Vx = array(BIGINTEGER_VARIABLE => array(), BIGINTEGER_DATA => array());
        if (!(($vt = array_search($c8, $Vx[BIGINTEGER_VARIABLE])) === false)) {
            goto qj;
        }
        $vt = count($Vx[BIGINTEGER_VARIABLE]);
        $Vx[BIGINTEGER_VARIABLE][] = $gJ;
        $Vx[BIGINTEGER_DATA][] = $this->_modInverse67108864($c8);
        qj:
        $yt = count($c8);
        $UZ = array(BIGINTEGER_VALUE => $gJ);
        $Tu = 0;
        R1:
        if (!($Tu < $yt)) {
            goto k0;
        }
        $bJ = $UZ[BIGINTEGER_VALUE][$Tu] * $Vx[BIGINTEGER_DATA][$vt];
        $bJ = $bJ - BIGINTEGER_BASE_FULL * (BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31);
        $bJ = $this->_regularMultiply(array($bJ), $c8);
        $bJ = array_merge($this->_array_repeat(0, $Tu), $bJ);
        $UZ = $this->_add($UZ[BIGINTEGER_VALUE], false, $bJ, false);
        yS:
        ++$Tu;
        goto R1;
        k0:
        $UZ[BIGINTEGER_VALUE] = array_slice($UZ[BIGINTEGER_VALUE], $yt);
        if (!($this->_compare($UZ, false, $c8, false) >= 0)) {
            goto vq;
        }
        $UZ = $this->_subtract($UZ[BIGINTEGER_VALUE], false, $c8, false);
        vq:
        return $UZ[BIGINTEGER_VALUE];
    }
    function _montgomeryMultiply($gJ, $qw, $qa)
    {
        $bJ = $this->_multiply($gJ, false, $qw, false);
        return $this->_montgomery($bJ[BIGINTEGER_VALUE], $qa);
        static $Vx = array(BIGINTEGER_VARIABLE => array(), BIGINTEGER_DATA => array());
        if (!(($vt = array_search($qa, $Vx[BIGINTEGER_VARIABLE])) === false)) {
            goto DD;
        }
        $vt = count($Vx[BIGINTEGER_VARIABLE]);
        $Vx[BIGINTEGER_VARIABLE][] = $qa;
        $Vx[BIGINTEGER_DATA][] = $this->_modInverse67108864($qa);
        DD:
        $c8 = max(count($gJ), count($qw), count($qa));
        $gJ = array_pad($gJ, $c8, 0);
        $qw = array_pad($qw, $c8, 0);
        $qa = array_pad($qa, $c8, 0);
        $tp = array(BIGINTEGER_VALUE => $this->_array_repeat(0, $c8 + 1));
        $Tu = 0;
        eS:
        if (!($Tu < $c8)) {
            goto eg;
        }
        $bJ = $tp[BIGINTEGER_VALUE][0] + $gJ[$Tu] * $qw[0];
        $bJ = $bJ - BIGINTEGER_BASE_FULL * (BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31);
        $bJ = $bJ * $Vx[BIGINTEGER_DATA][$vt];
        $bJ = $bJ - BIGINTEGER_BASE_FULL * (BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31);
        $bJ = $this->_add($this->_regularMultiply(array($gJ[$Tu]), $qw), false, $this->_regularMultiply(array($bJ), $qa), false);
        $tp = $this->_add($tp[BIGINTEGER_VALUE], false, $bJ[BIGINTEGER_VALUE], false);
        $tp[BIGINTEGER_VALUE] = array_slice($tp[BIGINTEGER_VALUE], 1);
        cA:
        ++$Tu;
        goto eS;
        eg:
        if (!($this->_compare($tp[BIGINTEGER_VALUE], false, $qa, false) >= 0)) {
            goto y5;
        }
        $tp = $this->_subtract($tp[BIGINTEGER_VALUE], false, $qa, false);
        y5:
        return $tp[BIGINTEGER_VALUE];
    }
    function _prepMontgomery($gJ, $c8)
    {
        $VZ = new BigInteger();
        $VZ->value = array_merge($this->_array_repeat(0, count($c8)), $gJ);
        $Dw = new BigInteger();
        $Dw->value = $c8;
        list(, $bJ) = $VZ->divide($Dw);
        return $bJ->value;
    }
    function _modInverse67108864($gJ)
    {
        $gJ = -$gJ[0];
        $UZ = $gJ & 0x3;
        $UZ = $UZ * (2 - $gJ * $UZ) & 0xf;
        $UZ = $UZ * (2 - ($gJ & 0xff) * $UZ) & 0xff;
        $UZ = $UZ * (2 - ($gJ & 0xffff) * $UZ & 0xffff) & 0xffff;
        $UZ = fmod($UZ * (2 - fmod($gJ * $UZ, BIGINTEGER_BASE_FULL)), BIGINTEGER_BASE_FULL);
        return $UZ & BIGINTEGER_MAX_DIGIT;
    }
    function modInverse($c8)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_invert($this->value, $c8->value);
                return $bJ->value === false ? false : $this->_normalize($bJ);
        }
        pV:
        DP:
        static $SJ, $Mt;
        if (isset($SJ)) {
            goto I4;
        }
        $SJ = new BigInteger();
        $Mt = new BigInteger(1);
        I4:
        $c8 = $c8->abs();
        if (!($this->compare($SJ) < 0)) {
            goto oW;
        }
        $bJ = $this->abs();
        $bJ = $bJ->modInverse($c8);
        return $this->_normalize($c8->subtract($bJ));
        oW:
        extract($this->extendedGCD($c8));
        if ($TC->equals($Mt)) {
            goto k2;
        }
        return false;
        k2:
        $gJ = $gJ->compare($SJ) < 0 ? $gJ->add($c8) : $gJ;
        return $this->compare($SJ) < 0 ? $this->_normalize($c8->subtract($gJ)) : $this->_normalize($gJ);
    }
    function extendedGCD($c8)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                extract(gmp_gcdext($this->value, $c8->value));
                return array("\147\143\144" => $this->_normalize(new BigInteger($Zb)), "\170" => $this->_normalize(new BigInteger($o7)), "\171" => $this->_normalize(new BigInteger($Nd)));
            case BIGINTEGER_MODE_BCMATH:
                $p4 = $this->value;
                $Oi = $c8->value;
                $tp = "\x31";
                $jt = "\60";
                $s1 = "\60";
                $Ob = "\x31";
                X2:
                if (!(bccomp($Oi, "\x30", 0) != 0)) {
                    goto h_;
                }
                $E8 = bcdiv($p4, $Oi, 0);
                $bJ = $p4;
                $p4 = $Oi;
                $Oi = bcsub($bJ, bcmul($Oi, $E8, 0), 0);
                $bJ = $tp;
                $tp = $s1;
                $s1 = bcsub($bJ, bcmul($tp, $E8, 0), 0);
                $bJ = $jt;
                $jt = $Ob;
                $Ob = bcsub($bJ, bcmul($jt, $E8, 0), 0);
                goto X2;
                h_:
                return array("\147\143\x64" => $this->_normalize(new BigInteger($p4)), "\x78" => $this->_normalize(new BigInteger($tp)), "\x79" => $this->_normalize(new BigInteger($jt)));
        }
        pf:
        GU:
        $qw = $c8->copy();
        $gJ = $this->copy();
        $Zb = new BigInteger();
        $Zb->value = array(1);
        wb:
        if ($gJ->value[0] & 1 || $qw->value[0] & 1) {
            goto gn;
        }
        $gJ->_rshift(1);
        $qw->_rshift(1);
        $Zb->_lshift(1);
        goto wb;
        gn:
        $p4 = $gJ->copy();
        $Oi = $qw->copy();
        $tp = new BigInteger();
        $jt = new BigInteger();
        $s1 = new BigInteger();
        $Ob = new BigInteger();
        $tp->value = $Ob->value = $Zb->value = array(1);
        $jt->value = $s1->value = array();
        Cd:
        if (empty($p4->value)) {
            goto EC;
        }
        hT:
        if ($p4->value[0] & 1) {
            goto xJ;
        }
        $p4->_rshift(1);
        if (!(!empty($tp->value) && $tp->value[0] & 1 || !empty($jt->value) && $jt->value[0] & 1)) {
            goto s1;
        }
        $tp = $tp->add($qw);
        $jt = $jt->subtract($gJ);
        s1:
        $tp->_rshift(1);
        $jt->_rshift(1);
        goto hT;
        xJ:
        c_:
        if ($Oi->value[0] & 1) {
            goto El;
        }
        $Oi->_rshift(1);
        if (!(!empty($Ob->value) && $Ob->value[0] & 1 || !empty($s1->value) && $s1->value[0] & 1)) {
            goto fb;
        }
        $s1 = $s1->add($qw);
        $Ob = $Ob->subtract($gJ);
        fb:
        $s1->_rshift(1);
        $Ob->_rshift(1);
        goto c_;
        El:
        if ($p4->compare($Oi) >= 0) {
            goto Ee;
        }
        $Oi = $Oi->subtract($p4);
        $s1 = $s1->subtract($tp);
        $Ob = $Ob->subtract($jt);
        goto k7;
        Ee:
        $p4 = $p4->subtract($Oi);
        $tp = $tp->subtract($s1);
        $jt = $jt->subtract($Ob);
        k7:
        goto Cd;
        EC:
        return array("\x67\143\144" => $this->_normalize($Zb->multiply($Oi)), "\x78" => $this->_normalize($s1), "\171" => $this->_normalize($Ob));
    }
    function gcd($c8)
    {
        extract($this->extendedGCD($c8));
        return $TC;
    }
    function abs()
    {
        $bJ = new BigInteger();
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ->value = gmp_abs($this->value);
                goto Oq;
            case BIGINTEGER_MODE_BCMATH:
                $bJ->value = bccomp($this->value, "\60", 0) < 0 ? substr($this->value, 1) : $this->value;
                goto Oq;
            default:
                $bJ->value = $this->value;
        }
        Cl:
        Oq:
        return $bJ;
    }
    function compare($qw)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                return gmp_cmp($this->value, $qw->value);
            case BIGINTEGER_MODE_BCMATH:
                return bccomp($this->value, $qw->value, 0);
        }
        vl:
        yU:
        return $this->_compare($this->value, $this->is_negative, $qw->value, $qw->is_negative);
    }
    function _compare($TQ, $rp, $PT, $zp)
    {
        if (!($rp != $zp)) {
            goto NJ;
        }
        return !$rp && $zp ? 1 : -1;
        NJ:
        $UZ = $rp ? -1 : 1;
        if (!(count($TQ) != count($PT))) {
            goto cN;
        }
        return count($TQ) > count($PT) ? $UZ : -$UZ;
        cN:
        $jS = max(count($TQ), count($PT));
        $TQ = array_pad($TQ, $jS, 0);
        $PT = array_pad($PT, $jS, 0);
        $Tu = count($TQ) - 1;
        ui:
        if (!($Tu >= 0)) {
            goto cf;
        }
        if (!($TQ[$Tu] != $PT[$Tu])) {
            goto BX;
        }
        return $TQ[$Tu] > $PT[$Tu] ? $UZ : -$UZ;
        BX:
        jb:
        --$Tu;
        goto ui;
        cf:
        return 0;
    }
    function equals($gJ)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                return gmp_cmp($this->value, $gJ->value) == 0;
            default:
                return $this->value === $gJ->value && $this->is_negative == $gJ->is_negative;
        }
        PY:
        jl:
    }
    function setPrecision($JQ)
    {
        $this->precision = $JQ;
        if (BIGINTEGER_MODE != BIGINTEGER_MODE_BCMATH) {
            goto Dn;
        }
        $this->bitmask = new BigInteger(bcpow("\62", $JQ, 0));
        goto ds;
        Dn:
        $this->bitmask = new BigInteger(chr((1 << ($JQ & 0x7)) - 1) . str_repeat(chr(0xff), $JQ >> 3), 256);
        ds:
        $bJ = $this->_normalize($this);
        $this->value = $bJ->value;
    }
    function bitwise_and($gJ)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_and($this->value, $gJ->value);
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $Vr = $this->toBytes();
                $vz = $gJ->toBytes();
                $RV = max(strlen($Vr), strlen($vz));
                $Vr = str_pad($Vr, $RV, chr(0), STR_PAD_LEFT);
                $vz = str_pad($vz, $RV, chr(0), STR_PAD_LEFT);
                return $this->_normalize(new BigInteger($Vr & $vz, 256));
        }
        zE:
        Kt:
        $UZ = $this->copy();
        $RV = min(count($gJ->value), count($this->value));
        $UZ->value = array_slice($UZ->value, 0, $RV);
        $Tu = 0;
        A0:
        if (!($Tu < $RV)) {
            goto WZ;
        }
        $UZ->value[$Tu] &= $gJ->value[$Tu];
        nZ:
        ++$Tu;
        goto A0;
        WZ:
        return $this->_normalize($UZ);
    }
    function bitwise_or($gJ)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_or($this->value, $gJ->value);
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $Vr = $this->toBytes();
                $vz = $gJ->toBytes();
                $RV = max(strlen($Vr), strlen($vz));
                $Vr = str_pad($Vr, $RV, chr(0), STR_PAD_LEFT);
                $vz = str_pad($vz, $RV, chr(0), STR_PAD_LEFT);
                return $this->_normalize(new BigInteger($Vr | $vz, 256));
        }
        HV:
        I8:
        $RV = max(count($this->value), count($gJ->value));
        $UZ = $this->copy();
        $UZ->value = array_pad($UZ->value, $RV, 0);
        $gJ->value = array_pad($gJ->value, $RV, 0);
        $Tu = 0;
        sJ:
        if (!($Tu < $RV)) {
            goto cd;
        }
        $UZ->value[$Tu] |= $gJ->value[$Tu];
        tN:
        ++$Tu;
        goto sJ;
        cd:
        return $this->_normalize($UZ);
    }
    function bitwise_xor($gJ)
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                $bJ = new BigInteger();
                $bJ->value = gmp_xor(gmp_abs($this->value), gmp_abs($gJ->value));
                return $this->_normalize($bJ);
            case BIGINTEGER_MODE_BCMATH:
                $Vr = $this->toBytes();
                $vz = $gJ->toBytes();
                $RV = max(strlen($Vr), strlen($vz));
                $Vr = str_pad($Vr, $RV, chr(0), STR_PAD_LEFT);
                $vz = str_pad($vz, $RV, chr(0), STR_PAD_LEFT);
                return $this->_normalize(new BigInteger($Vr ^ $vz, 256));
        }
        n8:
        my:
        $RV = max(count($this->value), count($gJ->value));
        $UZ = $this->copy();
        $UZ->is_negative = false;
        $UZ->value = array_pad($UZ->value, $RV, 0);
        $gJ->value = array_pad($gJ->value, $RV, 0);
        $Tu = 0;
        cr:
        if (!($Tu < $RV)) {
            goto zg;
        }
        $UZ->value[$Tu] ^= $gJ->value[$Tu];
        km:
        ++$Tu;
        goto cr;
        zg:
        return $this->_normalize($UZ);
    }
    function bitwise_not()
    {
        $bJ = $this->toBytes();
        if (!($bJ == '')) {
            goto SX;
        }
        return $this->_normalize(new BigInteger());
        SX:
        $y9 = decbin(ord($bJ[0]));
        $bJ = ~$bJ;
        $Ty = decbin(ord($bJ[0]));
        if (!(strlen($Ty) == 8)) {
            goto ks;
        }
        $Ty = substr($Ty, strpos($Ty, "\60"));
        ks:
        $bJ[0] = chr(bindec($Ty));
        $es = strlen($y9) + 8 * strlen($bJ) - 8;
        $JS = $this->precision - $es;
        if (!($JS <= 0)) {
            goto f3;
        }
        return $this->_normalize(new BigInteger($bJ, 256));
        f3:
        $hC = chr((1 << ($JS & 0x7)) - 1) . str_repeat(chr(0xff), $JS >> 3);
        $this->_base256_lshift($hC, $es);
        $bJ = str_pad($bJ, strlen($hC), chr(0), STR_PAD_LEFT);
        return $this->_normalize(new BigInteger($hC | $bJ, 256));
    }
    function bitwise_rightShift($YL)
    {
        $bJ = new BigInteger();
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                static $Rn;
                if (isset($Rn)) {
                    goto zP;
                }
                $Rn = gmp_init("\x32");
                zP:
                $bJ->value = gmp_div_q($this->value, gmp_pow($Rn, $YL));
                goto NS;
            case BIGINTEGER_MODE_BCMATH:
                $bJ->value = bcdiv($this->value, bcpow("\x32", $YL, 0), 0);
                goto NS;
            default:
                $bJ->value = $this->value;
                $bJ->_rshift($YL);
        }
        f8:
        NS:
        return $this->_normalize($bJ);
    }
    function bitwise_leftShift($YL)
    {
        $bJ = new BigInteger();
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                static $Rn;
                if (isset($Rn)) {
                    goto PP;
                }
                $Rn = gmp_init("\x32");
                PP:
                $bJ->value = gmp_mul($this->value, gmp_pow($Rn, $YL));
                goto io;
            case BIGINTEGER_MODE_BCMATH:
                $bJ->value = bcmul($this->value, bcpow("\x32", $YL, 0), 0);
                goto io;
            default:
                $bJ->value = $this->value;
                $bJ->_lshift($YL);
        }
        J_:
        io:
        return $this->_normalize($bJ);
    }
    function bitwise_leftRotate($YL)
    {
        $JQ = $this->toBytes();
        if ($this->precision > 0) {
            goto k8;
        }
        $bJ = ord($JQ[0]);
        $Tu = 0;
        kZ:
        if (!($bJ >> $Tu)) {
            goto fU;
        }
        Cm:
        ++$Tu;
        goto kZ;
        fU:
        $Le = 8 * strlen($JQ) - 8 + $Tu;
        $lB = chr((1 << ($Le & 0x7)) - 1) . str_repeat(chr(0xff), $Le >> 3);
        goto RN;
        k8:
        $Le = $this->precision;
        if (BIGINTEGER_MODE == BIGINTEGER_MODE_BCMATH) {
            goto Nn;
        }
        $lB = $this->bitmask->toBytes();
        goto xq;
        Nn:
        $lB = $this->bitmask->subtract(new BigInteger(1));
        $lB = $lB->toBytes();
        xq:
        RN:
        if (!($YL < 0)) {
            goto hd;
        }
        $YL += $Le;
        hd:
        $YL %= $Le;
        if ($YL) {
            goto Nb;
        }
        return $this->copy();
        Nb:
        $Vr = $this->bitwise_leftShift($YL);
        $Vr = $Vr->bitwise_and(new BigInteger($lB, 256));
        $vz = $this->bitwise_rightShift($Le - $YL);
        $UZ = BIGINTEGER_MODE != BIGINTEGER_MODE_BCMATH ? $Vr->bitwise_or($vz) : $Vr->add($vz);
        return $this->_normalize($UZ);
    }
    function bitwise_rightRotate($YL)
    {
        return $this->bitwise_leftRotate(-$YL);
    }
    function setRandomGenerator($Df)
    {
    }
    function _random_number_helper($jS)
    {
        if (function_exists("\143\x72\171\160\164\137\x72\x61\x6e\144\x6f\155\137\163\x74\x72\151\x6e\x67")) {
            goto fA;
        }
        $zi = '';
        if (!($jS & 1)) {
            goto Y8;
        }
        $zi .= chr(mt_rand(0, 255));
        Y8:
        $nr = $jS >> 1;
        $Tu = 0;
        nG:
        if (!($Tu < $nr)) {
            goto bG;
        }
        $zi .= pack("\x6e", mt_rand(0, 0xffff));
        QU:
        ++$Tu;
        goto nG;
        bG:
        goto IZ;
        fA:
        $zi = crypt_random_string($jS);
        IZ:
        return new BigInteger($zi, 256);
    }
    function random($Nv, $Y1 = false)
    {
        if (!($Nv === false)) {
            goto T2;
        }
        return false;
        T2:
        if ($Y1 === false) {
            goto Od;
        }
        $D8 = $Nv;
        $KJ = $Y1;
        goto N8;
        Od:
        $KJ = $Nv;
        $D8 = $this;
        N8:
        $AL = $KJ->compare($D8);
        if (!$AL) {
            goto eh;
        }
        if ($AL < 0) {
            goto Nt;
        }
        goto Ba;
        eh:
        return $this->_normalize($D8);
        goto Ba;
        Nt:
        $bJ = $KJ;
        $KJ = $D8;
        $D8 = $bJ;
        Ba:
        static $Mt;
        if (isset($Mt)) {
            goto pl;
        }
        $Mt = new BigInteger(1);
        pl:
        $KJ = $KJ->subtract($D8->subtract($Mt));
        $jS = strlen(ltrim($KJ->toBytes(), chr(0)));
        $tz = new BigInteger(chr(1) . str_repeat("\0", $jS), 256);
        $zi = $this->_random_number_helper($jS);
        list($Fn) = $tz->divide($KJ);
        $Fn = $Fn->multiply($KJ);
        Kl:
        if (!($zi->compare($Fn) >= 0)) {
            goto pX;
        }
        $zi = $zi->subtract($Fn);
        $tz = $tz->subtract($Fn);
        $zi = $zi->bitwise_leftShift(8);
        $zi = $zi->add($this->_random_number_helper(1));
        $tz = $tz->bitwise_leftShift(8);
        list($Fn) = $tz->divide($KJ);
        $Fn = $Fn->multiply($KJ);
        goto Kl;
        pX:
        list(, $zi) = $zi->divide($KJ);
        return $this->_normalize($zi->add($D8));
    }
    function randomPrime($Nv, $Y1 = false, $rZ = false)
    {
        if (!($Nv === false)) {
            goto Mt;
        }
        return false;
        Mt:
        if ($Y1 === false) {
            goto vH;
        }
        $D8 = $Nv;
        $KJ = $Y1;
        goto Gs;
        vH:
        $KJ = $Nv;
        $D8 = $this;
        Gs:
        $AL = $KJ->compare($D8);
        if (!$AL) {
            goto Ke;
        }
        if ($AL < 0) {
            goto Rk;
        }
        goto r7;
        Ke:
        return $D8->isPrime() ? $D8 : false;
        goto r7;
        Rk:
        $bJ = $KJ;
        $KJ = $D8;
        $D8 = $bJ;
        r7:
        static $Mt, $Rn;
        if (isset($Mt)) {
            goto cX;
        }
        $Mt = new BigInteger(1);
        $Rn = new BigInteger(2);
        cX:
        $Fw = time();
        $gJ = $this->random($D8, $KJ);
        if (!(BIGINTEGER_MODE == BIGINTEGER_MODE_GMP && extension_loaded("\147\155\x70") && version_compare(PHP_VERSION, "\x35\x2e\62\x2e\x30", "\x3e\75"))) {
            goto HL;
        }
        $h9 = new BigInteger();
        $h9->value = gmp_nextprime($gJ->value);
        if (!($h9->compare($KJ) <= 0)) {
            goto Jn;
        }
        return $h9;
        Jn:
        if ($D8->equals($gJ)) {
            goto Lh;
        }
        $gJ = $gJ->subtract($Mt);
        Lh:
        return $gJ->randomPrime($D8, $gJ);
        HL:
        if (!$gJ->equals($Rn)) {
            goto DL;
        }
        return $gJ;
        DL:
        $gJ->_make_odd();
        if (!($gJ->compare($KJ) > 0)) {
            goto A2;
        }
        if (!$D8->equals($KJ)) {
            goto Bi;
        }
        return false;
        Bi:
        $gJ = $D8->copy();
        $gJ->_make_odd();
        A2:
        $R5 = $gJ->copy();
        SM:
        if (!true) {
            goto U1;
        }
        if (!($rZ !== false && time() - $Fw > $rZ)) {
            goto p9;
        }
        return false;
        p9:
        if (!$gJ->isPrime()) {
            goto VK;
        }
        return $gJ;
        VK:
        $gJ = $gJ->add($Rn);
        if (!($gJ->compare($KJ) > 0)) {
            goto cS;
        }
        $gJ = $D8->copy();
        if (!$gJ->equals($Rn)) {
            goto XA;
        }
        return $gJ;
        XA:
        $gJ->_make_odd();
        cS:
        if (!$gJ->equals($R5)) {
            goto m8;
        }
        return false;
        m8:
        goto SM;
        U1:
    }
    function _make_odd()
    {
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                gmp_setbit($this->value, 0);
                goto oi;
            case BIGINTEGER_MODE_BCMATH:
                if (!($this->value[strlen($this->value) - 1] % 2 == 0)) {
                    goto Vd;
                }
                $this->value = bcadd($this->value, "\61");
                Vd:
                goto oi;
            default:
                $this->value[0] |= 1;
        }
        bB:
        oi:
    }
    function isPrime($Nd = false)
    {
        $RV = strlen($this->toBytes());
        if ($Nd) {
            goto GN;
        }
        if ($RV >= 163) {
            goto wa;
        }
        if ($RV >= 106) {
            goto sQ;
        }
        if ($RV >= 81) {
            goto wp;
        }
        if ($RV >= 68) {
            goto s9;
        }
        if ($RV >= 56) {
            goto T5;
        }
        if ($RV >= 50) {
            goto X4;
        }
        if ($RV >= 43) {
            goto nn;
        }
        if ($RV >= 37) {
            goto mg;
        }
        if ($RV >= 31) {
            goto Wt;
        }
        if ($RV >= 25) {
            goto RL;
        }
        if ($RV >= 18) {
            goto gf;
        }
        $Nd = 27;
        goto Xt;
        gf:
        $Nd = 18;
        Xt:
        goto fH;
        RL:
        $Nd = 15;
        fH:
        goto pi;
        Wt:
        $Nd = 12;
        pi:
        goto JG;
        mg:
        $Nd = 9;
        JG:
        goto vw;
        nn:
        $Nd = 8;
        vw:
        goto Hy;
        X4:
        $Nd = 7;
        Hy:
        goto JB;
        T5:
        $Nd = 6;
        JB:
        goto bf;
        s9:
        $Nd = 5;
        bf:
        goto ig;
        wp:
        $Nd = 4;
        ig:
        goto sB;
        sQ:
        $Nd = 3;
        sB:
        goto cY;
        wa:
        $Nd = 2;
        cY:
        GN:
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                return gmp_prob_prime($this->value, $Nd) != 0;
            case BIGINTEGER_MODE_BCMATH:
                if (!($this->value === "\x32")) {
                    goto ZM;
                }
                return true;
                ZM:
                if (!($this->value[strlen($this->value) - 1] % 2 == 0)) {
                    goto aE;
                }
                return false;
                aE:
                goto b6;
            default:
                if (!($this->value == array(2))) {
                    goto pU;
                }
                return true;
                pU:
                if (!(~$this->value[0] & 1)) {
                    goto vr;
                }
                return false;
                vr:
        }
        Dg:
        b6:
        static $mX, $SJ, $Mt, $Rn;
        if (isset($mX)) {
            goto HK;
        }
        $mX = array(3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997);
        if (!(BIGINTEGER_MODE != BIGINTEGER_MODE_INTERNAL)) {
            goto yt;
        }
        $Tu = 0;
        y_:
        if (!($Tu < count($mX))) {
            goto oq;
        }
        $mX[$Tu] = new BigInteger($mX[$Tu]);
        Ln:
        ++$Tu;
        goto y_;
        oq:
        yt:
        $SJ = new BigInteger();
        $Mt = new BigInteger(1);
        $Rn = new BigInteger(2);
        HK:
        if (!$this->equals($Mt)) {
            goto Lu;
        }
        return false;
        Lu:
        if (BIGINTEGER_MODE != BIGINTEGER_MODE_INTERNAL) {
            goto aV;
        }
        $Rb = $this->value;
        foreach ($mX as $Zu) {
            list(, $zZ) = $this->_divide_digit($Rb, $Zu);
            if ($zZ) {
                goto DY;
            }
            return count($Rb) == 1 && $Rb[0] == $Zu;
            DY:
            K2:
        }
        lW:
        goto gh;
        aV:
        foreach ($mX as $Zu) {
            list(, $zZ) = $this->divide($Zu);
            if (!$zZ->equals($SJ)) {
                goto Nl;
            }
            return $this->equals($Zu);
            Nl:
            il:
        }
        fZ:
        gh:
        $c8 = $this->copy();
        $GX = $c8->subtract($Mt);
        $v8 = $c8->subtract($Rn);
        $zZ = $GX->copy();
        $x6 = $zZ->value;
        if (BIGINTEGER_MODE == BIGINTEGER_MODE_BCMATH) {
            goto cP;
        }
        $Tu = 0;
        $Cy = count($x6);
        pg:
        if (!($Tu < $Cy)) {
            goto Nw;
        }
        $bJ = ~$x6[$Tu] & 0xffffff;
        $i9 = 1;
        Qo:
        if (!($bJ >> $i9 & 1)) {
            goto bk;
        }
        yY:
        ++$i9;
        goto Qo;
        bk:
        if (!($i9 != 25)) {
            goto ym;
        }
        goto Nw;
        ym:
        vT:
        ++$Tu;
        goto pg;
        Nw:
        $o7 = 26 * $Tu + $i9;
        $zZ->_rshift($o7);
        goto N5;
        cP:
        $o7 = 0;
        s7:
        if (!($zZ->value[strlen($zZ->value) - 1] % 2 == 0)) {
            goto vO;
        }
        $zZ->value = bcdiv($zZ->value, "\x32", 0);
        ++$o7;
        goto s7;
        vO:
        N5:
        $Tu = 0;
        g_:
        if (!($Tu < $Nd)) {
            goto ZV;
        }
        $tp = $this->random($Rn, $v8);
        $qw = $tp->modPow($zZ, $c8);
        if (!(!$qw->equals($Mt) && !$qw->equals($GX))) {
            goto jO;
        }
        $i9 = 1;
        cg:
        if (!($i9 < $o7 && !$qw->equals($GX))) {
            goto mv;
        }
        $qw = $qw->modPow($Rn, $c8);
        if (!$qw->equals($Mt)) {
            goto ip;
        }
        return false;
        ip:
        nR:
        ++$i9;
        goto cg;
        mv:
        if ($qw->equals($GX)) {
            goto Fe;
        }
        return false;
        Fe:
        jO:
        O7:
        ++$Tu;
        goto g_;
        ZV:
        return true;
    }
    function _lshift($YL)
    {
        if (!($YL == 0)) {
            goto e2;
        }
        return;
        e2:
        $eE = (int) ($YL / BIGINTEGER_BASE);
        $YL %= BIGINTEGER_BASE;
        $YL = 1 << $YL;
        $Q1 = 0;
        $Tu = 0;
        A7:
        if (!($Tu < count($this->value))) {
            goto sH;
        }
        $bJ = $this->value[$Tu] * $YL + $Q1;
        $Q1 = BIGINTEGER_BASE === 26 ? intval($bJ / 0x4000000) : $bJ >> 31;
        $this->value[$Tu] = (int) ($bJ - $Q1 * BIGINTEGER_BASE_FULL);
        Xv:
        ++$Tu;
        goto A7;
        sH:
        if (!$Q1) {
            goto mU;
        }
        $this->value[count($this->value)] = $Q1;
        mU:
        nT:
        if (!$eE--) {
            goto MO;
        }
        array_unshift($this->value, 0);
        goto nT;
        MO:
    }
    function _rshift($YL)
    {
        if (!($YL == 0)) {
            goto Hx;
        }
        return;
        Hx:
        $eE = (int) ($YL / BIGINTEGER_BASE);
        $YL %= BIGINTEGER_BASE;
        $HZ = BIGINTEGER_BASE - $YL;
        $N9 = (1 << $YL) - 1;
        if (!$eE) {
            goto GP;
        }
        $this->value = array_slice($this->value, $eE);
        GP:
        $Q1 = 0;
        $Tu = count($this->value) - 1;
        Gb:
        if (!($Tu >= 0)) {
            goto Ih;
        }
        $bJ = $this->value[$Tu] >> $YL | $Q1;
        $Q1 = ($this->value[$Tu] & $N9) << $HZ;
        $this->value[$Tu] = $bJ;
        Ud:
        --$Tu;
        goto Gb;
        Ih:
        $this->value = $this->_trim($this->value);
    }
    function _normalize($UZ)
    {
        $UZ->precision = $this->precision;
        $UZ->bitmask = $this->bitmask;
        switch (BIGINTEGER_MODE) {
            case BIGINTEGER_MODE_GMP:
                if (!($this->bitmask !== false)) {
                    goto ya;
                }
                $UZ->value = gmp_and($UZ->value, $UZ->bitmask->value);
                ya:
                return $UZ;
            case BIGINTEGER_MODE_BCMATH:
                if (empty($UZ->bitmask->value)) {
                    goto ht;
                }
                $UZ->value = bcmod($UZ->value, $UZ->bitmask->value);
                ht:
                return $UZ;
        }
        KV:
        Uq:
        $Rb =& $UZ->value;
        if (count($Rb)) {
            goto lZ;
        }
        return $UZ;
        lZ:
        $Rb = $this->_trim($Rb);
        if (empty($UZ->bitmask->value)) {
            goto lk;
        }
        $RV = min(count($Rb), count($this->bitmask->value));
        $Rb = array_slice($Rb, 0, $RV);
        $Tu = 0;
        PN:
        if (!($Tu < $RV)) {
            goto o2;
        }
        $Rb[$Tu] = $Rb[$Tu] & $this->bitmask->value[$Tu];
        VF:
        ++$Tu;
        goto PN;
        o2:
        lk:
        return $UZ;
    }
    function _trim($Rb)
    {
        $Tu = count($Rb) - 1;
        nw:
        if (!($Tu >= 0)) {
            goto AF;
        }
        if (!$Rb[$Tu]) {
            goto Cs;
        }
        goto AF;
        Cs:
        unset($Rb[$Tu]);
        RY:
        --$Tu;
        goto nw;
        AF:
        return $Rb;
    }
    function _array_repeat($k4, $ly)
    {
        return $ly ? array_fill(0, $ly, $k4) : array();
    }
    function _base256_lshift(&$gJ, $YL)
    {
        if (!($YL == 0)) {
            goto E4;
        }
        return;
        E4:
        $RK = $YL >> 3;
        $YL &= 7;
        $Q1 = 0;
        $Tu = strlen($gJ) - 1;
        Bx:
        if (!($Tu >= 0)) {
            goto ee;
        }
        $bJ = ord($gJ[$Tu]) << $YL | $Q1;
        $gJ[$Tu] = chr($bJ);
        $Q1 = $bJ >> 8;
        OZ:
        --$Tu;
        goto Bx;
        ee:
        $Q1 = $Q1 != 0 ? chr($Q1) : '';
        $gJ = $Q1 . $gJ . str_repeat(chr(0), $RK);
    }
    function _base256_rshift(&$gJ, $YL)
    {
        if (!($YL == 0)) {
            goto pb;
        }
        $gJ = ltrim($gJ, chr(0));
        return '';
        pb:
        $RK = $YL >> 3;
        $YL &= 7;
        $bt = '';
        if (!$RK) {
            goto b3;
        }
        $Fw = $RK > strlen($gJ) ? -strlen($gJ) : -$RK;
        $bt = substr($gJ, $Fw);
        $gJ = substr($gJ, 0, -$RK);
        b3:
        $Q1 = 0;
        $HZ = 8 - $YL;
        $Tu = 0;
        ej:
        if (!($Tu < strlen($gJ))) {
            goto Hz;
        }
        $bJ = ord($gJ[$Tu]) >> $YL | $Q1;
        $Q1 = ord($gJ[$Tu]) << $HZ & 0xff;
        $gJ[$Tu] = chr($bJ);
        bJ:
        ++$Tu;
        goto ej;
        Hz:
        $gJ = ltrim($gJ, chr(0));
        $bt = chr($Q1 >> $HZ) . $bt;
        return ltrim($bt, chr(0));
    }
    function _int2bytes($gJ)
    {
        return ltrim(pack("\x4e", $gJ), chr(0));
    }
    function _bytes2int($gJ)
    {
        $bJ = unpack("\116\151\x6e\164", str_pad($gJ, 4, chr(0), STR_PAD_LEFT));
        return $bJ["\151\x6e\164"];
    }
    function _encodeASN1Length($RV)
    {
        if (!($RV <= 0x7f)) {
            goto LT;
        }
        return chr($RV);
        LT:
        $bJ = ltrim(pack("\x4e", $RV), chr(0));
        return pack("\x43\141\52", 0x80 | strlen($bJ), $bJ);
    }
    function _safe_divide($gJ, $qw)
    {
        if (!(BIGINTEGER_BASE === 26)) {
            goto n4;
        }
        return (int) ($gJ / $qw);
        n4:
        return ($gJ - $gJ % $qw) / $qw;
    }
}