function fact($x)
{
    if ($x <= 1) {
        return 1;
    }
    return gmp_mul($x, fact($x - 1));
}

function GetFriendID($pszAuthID)
{
    $iServer = "0";
    $iAuthID = "0";
    $szAuthID = $pszAuthID;
    $szTmp = strtok($szAuthID, ":");
    while (($szTmp = strtok(":")) !== false) {
        $szTmp2 = strtok(":");
        if ($szTmp2 !== false) {
            $iServer = $szTmp;
            $iAuthID = $szTmp2;
        }
    }
    if ($iAuthID == "0") {
        return false;
    }
    if (extension_loaded('bcmath') == 1) {
        // calc communityid with bcmath
        $i64friendID = bcmul($iAuthID, "2");
        $i64friendID = bcadd($i64friendID, bcadd("76561197960265728", $iServer, 0), 0);
        return $i64friendID;
    } else {
        if (extension_loaded('gmp') == 1) {
            // calc communityid with gmp
            $i64friendID = gmp_mul($iAuthID, "2");
            $i64friendID = gmp_add($i64friendID, gmp_add("76561197960265728", $iServer));
            return gmp_strval($i64friendID);
        } else {
            $i64friendID = Mul(strval($iAuthID), "2");
            $i64friendID = Add(strval($i64friendID), Add("76561197960265728", strval($iServer)));
            return $i64friendID;
        }
    }
    return false;
}

 public function setValue(Content $content)
 {
     $binaryData = $content->binaryData;
     $offsetIndex = 0;
     $contentLength = $this->contentLength->length;
     $isNegative = (ord($binaryData[$offsetIndex]) & 0x80) != 0x0;
     $number = gmp_init(ord($binaryData[$offsetIndex++]) & 0x7f, 10);
     for ($i = 0; $i < $contentLength - 1; $i++) {
         $number = gmp_or(gmp_mul($number, 0x100), ord($binaryData[$offsetIndex++]));
     }
     if ($isNegative) {
         $number = gmp_sub($number, gmp_pow(2, 8 * $contentLength - 1));
     }
     $value = gmp_strval($number, 10);
     if (is_string($value)) {
         // remove gaps between hex digits
         $value = preg_replace('/\\s|0x/', '', $value);
     } elseif (is_numeric($value)) {
         $value = dechex($value);
     } else {
         throw new Exception('OctetString: unrecognized input type!');
     }
     if (strlen($value) % 2 != 0) {
         // transform values like 1F2 to 01F2
         $value = '0' . $value;
     }
     $this->value = $value;
 }

function get_funds_graph_data()
{
    $btc = array();
    $fiat = array();
    $query = "\n        SELECT\n            req_type, amount, curr_type, " . sql_format_date('timest') . " AS timest2\n        FROM\n            requests\n        WHERE\n            status != 'CANCEL'\n        ORDER BY\n            timest;\n    ";
    $result = do_query($query);
    $btc_sum = 0;
    $fiat_sum = 0;
    while ($row = mysql_fetch_array($result)) {
        $req_type = $row['req_type'];
        $amount = $row['amount'];
        $curr_type = $row['curr_type'];
        $timest = $row['timest2'];
        if ($req_type == 'WITHDR') {
            $amount = gmp_mul(-1, $amount);
        }
        if ($curr_type == 'BTC') {
            $btc_sum = gmp_add($btc_sum, $amount);
            $btc[$timest] = internal_to_numstr($btc_sum);
        } else {
            $fiat_sum = gmp_add($fiat_sum, $amount);
            $fiat[$timest] = internal_to_numstr($fiat_sum);
        }
    }
    return array($btc, $fiat);
}

 /**
  * Convert 32-bit SteamID to 64-bit SteamID
  *
  * @param string|int $userId
  *
  * @return string
  * @throws Exception
  */
 public static function to64Bit($userId)
 {
     if (!function_exists('gmp_add')) {
         throw new Exception("GMP Library not installed. Cannot convert SteamIDs.");
     }
     return gmp_strval(gmp_add(gmp_mul(sprintf("%u", bindec(self::STEAM_ID_UPPER_BITS)), "4294967296"), sprintf("%u", $userId)));
 }

 protected function assetNameToIDHex($asset_name)
 {
     if ($asset_name == 'BTC') {
         return '0';
     }
     if ($asset_name == 'XCP') {
         return '1';
     }
     if (substr($asset_name, 0, 1) == 'A') {
         // numerical asset
         // An integer between 26^12 + 1 and 256^8 (inclusive)
         $asset_id = gmp_init(substr($asset_name, 1));
         if ($asset_id < gmp_init(26) ** 12 + 1) {
             throw new Exception("Asset ID was too low", 1);
         }
         if ($asset_id > gmp_init(2) ** 64 - 1) {
             throw new Exception("Asset ID was too high", 1);
         }
         return gmp_strval($asset_id, 16);
     }
     $n = gmp_init(0);
     for ($i = 0; $i < strlen($asset_name); $i++) {
         $n = gmp_mul($n, 26);
         $char = ord(substr($asset_name, $i, 1));
         if ($char < 65 or $char > 90) {
             throw new Exception("Asset name invalid", 1);
         }
         $digit = $char - 65;
         $n = gmp_add($n, $digit);
     }
     return gmp_strval($n, 16);
 }

 public function testMul()
 {
     $this->assertEquals(gmp_strval(gmp_mul($this->a, $this->a)), $this->math->mul($this->a, $this->a));
     $this->assertEquals(gmp_strval(gmp_mul($this->b, $this->b)), $this->math->mul($this->b, $this->b));
     $this->assertEquals(gmp_strval(gmp_mul($this->c, $this->c)), $this->math->mul($this->c, $this->c));
     $this->assertEquals(1, $this->math->mul(1, 1));
 }

 /**
 * binary decode using gmp extension 
 */
 private static function _bindecGmp($bin)
 {
     $dec = gmp_init(0);
     for ($i = 0; $i < strlen($bin); $i++) {
         $dec = gmp_add(gmp_mul($dec, 256), ord($bin[$i]));
     }
     return $dec;
 }

 public function bin2dec($bin)
 {
     $dec = '0';
     for ($i = 0, $len = strlen($bin); $i < $len; $i++) {
         $dec = gmp_add(gmp_mul($dec, 2), $bin[$i]);
     }
     return $dec;
 }

function fact($x)
{
    $return = 1;
    for ($i = 2; $i <= $x; $i++) {
        $return = gmp_mul($return, $i);
    }
    return $return;
}

 private function makeId32($timestamp, $machine, $sequence)
 {
     $timestamp = gmp_mul((string) $timestamp, gmp_pow(2, 22));
     $machine = gmp_mul((string) $machine, gmp_pow(2, 12));
     $sequence = gmp_init((string) $sequence, 10);
     $value = gmp_or(gmp_or($timestamp, $machine), $sequence);
     return gmp_strval($value, 10);
 }

function extractd(&$n1, &$n2, $d, $y)
{
    global $u;
    $u = gmp_mul($d, gmp_mul(-10, $y));
    $n1 = gmp_mul($n1, 10);
    $n1 = gmp_add($n1, $u);
    $n2 = gmp_mul($n2, 10);
    $n2 = gmp_add($n2, $u);
}

 public function generate($serial)
 {
     $mul = gmp_mul(strval($this->mulFactor), strval($serial));
     $add = gmp_add($mul, $this->diffFactor);
     $mod = gmp_mod($add, strval($this->amount));
     $num = gmp_strval($mod);
     //        $num = ($this->mulFactor * $serial + $this->diffFactor) % $this->amount;
     return str_pad($num, $this->length, $this->padding, STR_PAD_LEFT);
 }

 /**
  * @param $value
  *
  * @return string
  */
 public static function getBits($value)
 {
     $bits = [];
     for ($i = gmp_init(1); gmp_cmp($value, $i) >= 0; $i = gmp_mul($i, 2)) {
         if (static::has($value, $i)) {
             $bits[] = gmp_strval($i);
         }
     }
     return $bits;
 }

function readNumber($fd, $len)
{
    $val = gmp_init(0);
    for ($inx = 0; $inx < $len; $inx++) {
        $data = fread($fd, 1);
        $val = gmp_mul($val, gmp_init(256));
        $val = gmp_add($val, gmp_init(ord($data[0])));
    }
    return $val;
}

 function loadbits($bits)
 {
     foreach ($bits as $key => $value) {
         $this->_bitmap[$key] = $value;
         if ($value > $this->_curbit) {
             $this->_curbit = $value;
         }
     }
     $this->_curbit = gmp_mul($this->_curbit, 2);
 }

 public function edwards($P, $Q)
 {
     $x1 = $P[0];
     $y1 = $P[1];
     $x2 = $Q[0];
     $y2 = $Q[1];
     $t = gmp_mul($this->params['d'], gmp_mul(gmp_mul($x1, $x2), gmp_mul($y1, $y2)));
     $x3 = gmp_mul(gmp_add(gmp_mul($x1, $y2), gmp_mul($x2, $y1)), $this->inv(gmp_add(1, $t)));
     $y3 = gmp_mul(gmp_add(gmp_mul($y1, $y2), gmp_mul($x1, $x2)), $this->inv(gmp_sub(1, $t)));
     return array(gmp_mod($x3, $this->params['q']), gmp_mod($y3, $this->params['q']));
 }

 private function computeBaseNDigits($number, $targetBase)
 {
     $digits = array();
     $length = $this->computeBaseNLength($number, $targetBase);
     for ($i = 0; $i < $length; $i++) {
         $pow = gmp_pow($targetBase, $length - $i - 1);
         $div = gmp_div($number, $pow, GMP_ROUND_ZERO);
         $number = gmp_sub($number, gmp_mul($div, $pow));
         $digits[] = $div;
     }
     return array_map('gmp_strval', $digits);
 }

 /**
  * Decode an integer.
  *
  * @param  int $value
  * @return int
  */
 public function decode($value)
 {
     if (!is_numeric($value)) {
         throw new InvalidArgumentException('Argument should be an integer');
     }
     switch (static::$mode) {
         case static::MODE_GMP:
             return gmp_intval(gmp_mul((int) $value ^ $this->xor, $this->inverse)) & static::MAX_INT;
         default:
             return ((int) $value ^ $this->xor) * $this->inverse & static::MAX_INT;
     }
 }

 public function verifies($hash, Signature $signature)
 {
     if (extension_loaded('gmp') && USE_EXT == 'GMP') {
         $G = $this->generator;
         $n = $this->generator->getOrder();
         $point = $this->point;
         $r = $signature->getR();
         $s = $signature->getS();
         if (gmp_cmp($r, 1) < 0 || gmp_cmp($r, gmp_sub($n, 1)) > 0) {
             return false;
         }
         if (gmp_cmp($s, 1) < 0 || gmp_cmp($s, gmp_sub($n, 1)) > 0) {
             return false;
         }
         $c = NumberTheory::inverse_mod($s, $n);
         $u1 = gmp_Utils::gmp_mod2(gmp_mul($hash, $c), $n);
         $u2 = gmp_Utils::gmp_mod2(gmp_mul($r, $c), $n);
         $xy = Point::add(Point::mul($u1, $G), Point::mul($u2, $point));
         $v = gmp_Utils::gmp_mod2($xy->getX(), $n);
         if (gmp_cmp($v, $r) == 0) {
             return true;
         } else {
             return false;
         }
     } else {
         if (extension_loaded('bcmath') && USE_EXT == 'BCMATH') {
             $G = $this->generator;
             $n = $this->generator->getOrder();
             $point = $this->point;
             $r = $signature->getR();
             $s = $signature->getS();
             if (bccomp($r, 1) == -1 || bccomp($r, bcsub($n, 1)) == 1) {
                 return false;
             }
             if (bccomp($s, 1) == -1 || bccomp($s, bcsub($n, 1)) == 1) {
                 return false;
             }
             $c = NumberTheory::inverse_mod($s, $n);
             $u1 = bcmod(bcmul($hash, $c), $n);
             $u2 = bcmod(bcmul($r, $c), $n);
             $xy = Point::add(Point::mul($u1, $G), Point::mul($u2, $point));
             $v = bcmod($xy->getX(), $n);
             if (bccomp($v, $r) == 0) {
                 return true;
             } else {
                 return false;
             }
         } else {
             throw new ErrorException("Please install BCMATH or GMP");
         }
     }
 }