One Hat Cyber Team

Edit File: Internal.tar

Calculator/GmpCalculator.php������������������������������������������������������������������������0000644�����������������00000004420�15107326727�0012115 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?php

declare(strict_types=1);

namespace Brick\Math\Internal\Calculator;

use Brick\Math\Internal\Calculator;

/**
 * Calculator implementation built around the GMP library.
 *
 * @internal
 *
 * @psalm-immutable
 */
class GmpCalculator extends Calculator
{
    public function add(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_add($a, $b));
    }

public function sub(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_sub($a, $b));
    }

public function mul(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_mul($a, $b));
    }

public function divQ(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_div_q($a, $b));
    }

public function divR(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_div_r($a, $b));
    }

public function divQR(string $a, string $b) : array
    {
        [$q, $r] = \gmp_div_qr($a, $b);

return [
            \gmp_strval($q),
            \gmp_strval($r)
        ];
    }

public function pow(string $a, int $e) : string
    {
        return \gmp_strval(\gmp_pow($a, $e));
    }

public function modInverse(string $x, string $m) : ?string
    {
        $result = \gmp_invert($x, $m);

if ($result === false) {
            return null;
        }

return \gmp_strval($result);
    }

public function modPow(string $base, string $exp, string $mod) : string
    {
        return \gmp_strval(\gmp_powm($base, $exp, $mod));
    }

public function gcd(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_gcd($a, $b));
    }

public function fromBase(string $number, int $base) : string
    {
        return \gmp_strval(\gmp_init($number, $base));
    }

public function toBase(string $number, int $base) : string
    {
        return \gmp_strval($number, $base);
    }

public function and(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_and($a, $b));
    }

public function or(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_or($a, $b));
    }

public function xor(string $a, string $b) : string
    {
        return \gmp_strval(\gmp_xor($a, $b));
    }

public function sqrt(string $n) : string
    {
        return \gmp_strval(\gmp_sqrt($n));
    }
}
������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������Calculator/BcMathCalculator.php���������������������������������������������������������������������0000644�����������������00000002766�15107326727�0012543 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?php

declare(strict_types=1);

namespace Brick\Math\Internal\Calculator;

use Brick\Math\Internal\Calculator;

/**
 * Calculator implementation built around the bcmath library.
 *
 * @internal
 *
 * @psalm-immutable
 */
class BcMathCalculator extends Calculator
{
    public function add(string $a, string $b) : string
    {
        return \bcadd($a, $b, 0);
    }

public function sub(string $a, string $b) : string
    {
        return \bcsub($a, $b, 0);
    }

public function mul(string $a, string $b) : string
    {
        return \bcmul($a, $b, 0);
    }

public function divQ(string $a, string $b) : string
    {
        return \bcdiv($a, $b, 0);
    }

/**
     * @psalm-suppress InvalidNullableReturnType
     * @psalm-suppress NullableReturnStatement
     */
    public function divR(string $a, string $b) : string
    {
        return \bcmod($a, $b, 0);
    }

public function divQR(string $a, string $b) : array
    {
        $q = \bcdiv($a, $b, 0);
        $r = \bcmod($a, $b, 0);

assert($r !== null);

return [$q, $r];
    }

public function pow(string $a, int $e) : string
    {
        return \bcpow($a, (string) $e, 0);
    }

public function modPow(string $base, string $exp, string $mod) : string
    {
        return \bcpowmod($base, $exp, $mod, 0);
    }

/**
     * @psalm-suppress InvalidNullableReturnType
     * @psalm-suppress NullableReturnStatement
     */
    public function sqrt(string $n) : string
    {
        return \bcsqrt($n, 0);
    }
}
����������Calculator/NativeCalculator.php���������������������������������������������������������������������0000644�����������������00000032665�15107326730�0012626 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?php

declare(strict_types=1);

namespace Brick\Math\Internal\Calculator;

use Brick\Math\Internal\Calculator;

/**
 * Calculator implementation using only native PHP code.
 *
 * @internal
 *
 * @psalm-immutable
 */
class NativeCalculator extends Calculator
{
    /**
     * The max number of digits the platform can natively add, subtract, multiply or divide without overflow.
     * For multiplication, this represents the max sum of the lengths of both operands.
     *
     * In addition, it is assumed that an extra digit can hold a carry (1) without overflowing.
     * Example: 32-bit: max number 1,999,999,999 (9 digits + carry)
     *          64-bit: max number 1,999,999,999,999,999,999 (18 digits + carry)
     */
    private int $maxDigits;

/**
     * @codeCoverageIgnore
     */
    public function __construct()
    {
        switch (PHP_INT_SIZE) {
            case 4:
                $this->maxDigits = 9;
                break;

case 8:
                $this->maxDigits = 18;
                break;

default:
                throw new \RuntimeException('The platform is not 32-bit or 64-bit as expected.');
        }
    }

public function add(string $a, string $b) : string
    {
        /**
         * @psalm-var numeric-string $a
         * @psalm-var numeric-string $b
         */
        $result = $a + $b;

if (is_int($result)) {
            return (string) $result;
        }

if ($a === '0') {
            return $b;
        }

if ($b === '0') {
            return $a;
        }

[$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);

$result = $aNeg === $bNeg ? $this->doAdd($aDig, $bDig) : $this->doSub($aDig, $bDig);

if ($aNeg) {
            $result = $this->neg($result);
        }

return $result;
    }

public function sub(string $a, string $b) : string
    {
        return $this->add($a, $this->neg($b));
    }

public function mul(string $a, string $b) : string
    {
        /**
         * @psalm-var numeric-string $a
         * @psalm-var numeric-string $b
         */
        $result = $a * $b;

if (is_int($result)) {
            return (string) $result;
        }

if ($a === '0' || $b === '0') {
            return '0';
        }

if ($a === '1') {
            return $b;
        }

if ($b === '1') {
            return $a;
        }

if ($a === '-1') {
            return $this->neg($b);
        }

if ($b === '-1') {
            return $this->neg($a);
        }

[$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);

$result = $this->doMul($aDig, $bDig);

if ($aNeg !== $bNeg) {
            $result = $this->neg($result);
        }

return $result;
    }

public function divQ(string $a, string $b) : string
    {
        return $this->divQR($a, $b)[0];
    }

public function divR(string $a, string $b): string
    {
        return $this->divQR($a, $b)[1];
    }

public function divQR(string $a, string $b) : array
    {
        if ($a === '0') {
            return ['0', '0'];
        }

if ($a === $b) {
            return ['1', '0'];
        }

if ($b === '1') {
            return [$a, '0'];
        }

if ($b === '-1') {
            return [$this->neg($a), '0'];
        }

/** @psalm-var numeric-string $a */
        $na = $a * 1; // cast to number

if (is_int($na)) {
            /** @psalm-var numeric-string $b */
            $nb = $b * 1;

if (is_int($nb)) {
                // the only division that may overflow is PHP_INT_MIN / -1,
                // which cannot happen here as we've already handled a divisor of -1 above.
                $r = $na % $nb;
                $q = ($na - $r) / $nb;

assert(is_int($q));

return [
                    (string) $q,
                    (string) $r
                ];
            }
        }

[$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);

[$q, $r] = $this->doDiv($aDig, $bDig);

if ($aNeg !== $bNeg) {
            $q = $this->neg($q);
        }

if ($aNeg) {
            $r = $this->neg($r);
        }

return [$q, $r];
    }

public function pow(string $a, int $e) : string
    {
        if ($e === 0) {
            return '1';
        }

if ($e === 1) {
            return $a;
        }

$odd = $e % 2;
        $e -= $odd;

$aa = $this->mul($a, $a);

/** @psalm-suppress PossiblyInvalidArgument We're sure that $e / 2 is an int now */
        $result = $this->pow($aa, $e / 2);

if ($odd === 1) {
            $result = $this->mul($result, $a);
        }

return $result;
    }

/**
     * Algorithm from: https://www.geeksforgeeks.org/modular-exponentiation-power-in-modular-arithmetic/
     */
    public function modPow(string $base, string $exp, string $mod) : string
    {
        // special case: the algorithm below fails with 0 power 0 mod 1 (returns 1 instead of 0)
        if ($base === '0' && $exp === '0' && $mod === '1') {
            return '0';
        }

// special case: the algorithm below fails with power 0 mod 1 (returns 1 instead of 0)
        if ($exp === '0' && $mod === '1') {
            return '0';
        }

$x = $base;

$res = '1';

// numbers are positive, so we can use remainder instead of modulo
        $x = $this->divR($x, $mod);

while ($exp !== '0') {
            if (in_array($exp[-1], ['1', '3', '5', '7', '9'])) { // odd
                $res = $this->divR($this->mul($res, $x), $mod);
            }

$exp = $this->divQ($exp, '2');
            $x = $this->divR($this->mul($x, $x), $mod);
        }

return $res;
    }

/**
     * Adapted from https://cp-algorithms.com/num_methods/roots_newton.html
     */
    public function sqrt(string $n) : string
    {
        if ($n === '0') {
            return '0';
        }

// initial approximation
        $x = \str_repeat('9', \intdiv(\strlen($n), 2) ?: 1);

$decreased = false;

for (;;) {
            $nx = $this->divQ($this->add($x, $this->divQ($n, $x)), '2');

if ($x === $nx || $this->cmp($nx, $x) > 0 && $decreased) {
                break;
            }

$decreased = $this->cmp($nx, $x) < 0;
            $x = $nx;
        }

return $x;
    }

/**
     * Performs the addition of two non-signed large integers.
     */
    private function doAdd(string $a, string $b) : string
    {
        [$a, $b, $length] = $this->pad($a, $b);

$carry = 0;
        $result = '';

for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) {
            $blockLength = $this->maxDigits;

if ($i < 0) {
                $blockLength += $i;
                /** @psalm-suppress LoopInvalidation */
                $i = 0;
            }

/** @psalm-var numeric-string $blockA */
            $blockA = \substr($a, $i, $blockLength);

/** @psalm-var numeric-string $blockB */
            $blockB = \substr($b, $i, $blockLength);

$sum = (string) ($blockA + $blockB + $carry);
            $sumLength = \strlen($sum);

if ($sumLength > $blockLength) {
                $sum = \substr($sum, 1);
                $carry = 1;
            } else {
                if ($sumLength < $blockLength) {
                    $sum = \str_repeat('0', $blockLength - $sumLength) . $sum;
                }
                $carry = 0;
            }

$result = $sum . $result;

if ($i === 0) {
                break;
            }
        }

if ($carry === 1) {
            $result = '1' . $result;
        }

return $result;
    }

/**
     * Performs the subtraction of two non-signed large integers.
     */
    private function doSub(string $a, string $b) : string
    {
        if ($a === $b) {
            return '0';
        }

// Ensure that we always subtract to a positive result: biggest minus smallest.
        $cmp = $this->doCmp($a, $b);

$invert = ($cmp === -1);

if ($invert) {
            $c = $a;
            $a = $b;
            $b = $c;
        }

[$a, $b, $length] = $this->pad($a, $b);

$carry = 0;
        $result = '';

$complement = 10 ** $this->maxDigits;

for ($i = $length - $this->maxDigits;; $i -= $this->maxDigits) {
            $blockLength = $this->maxDigits;

if ($i < 0) {
                $blockLength += $i;
                /** @psalm-suppress LoopInvalidation */
                $i = 0;
            }

/** @psalm-var numeric-string $blockA */
            $blockA = \substr($a, $i, $blockLength);

/** @psalm-var numeric-string $blockB */
            $blockB = \substr($b, $i, $blockLength);

$sum = $blockA - $blockB - $carry;

if ($sum < 0) {
                $sum += $complement;
                $carry = 1;
            } else {
                $carry = 0;
            }

$sum = (string) $sum;
            $sumLength = \strlen($sum);

if ($sumLength < $blockLength) {
                $sum = \str_repeat('0', $blockLength - $sumLength) . $sum;
            }

$result = $sum . $result;

if ($i === 0) {
                break;
            }
        }

// Carry cannot be 1 when the loop ends, as a > b
        assert($carry === 0);

$result = \ltrim($result, '0');

if ($invert) {
            $result = $this->neg($result);
        }

return $result;
    }

/**
     * Performs the multiplication of two non-signed large integers.
     */
    private function doMul(string $a, string $b) : string
    {
        $x = \strlen($a);
        $y = \strlen($b);

$maxDigits = \intdiv($this->maxDigits, 2);
        $complement = 10 ** $maxDigits;

$result = '0';

for ($i = $x - $maxDigits;; $i -= $maxDigits) {
            $blockALength = $maxDigits;

if ($i < 0) {
                $blockALength += $i;
                /** @psalm-suppress LoopInvalidation */
                $i = 0;
            }

$blockA = (int) \substr($a, $i, $blockALength);

$line = '';
            $carry = 0;

for ($j = $y - $maxDigits;; $j -= $maxDigits) {
                $blockBLength = $maxDigits;

if ($j < 0) {
                    $blockBLength += $j;
                    /** @psalm-suppress LoopInvalidation */
                    $j = 0;
                }

$blockB = (int) \substr($b, $j, $blockBLength);

$mul = $blockA * $blockB + $carry;
                $value = $mul % $complement;
                $carry = ($mul - $value) / $complement;

$value = (string) $value;
                $value = \str_pad($value, $maxDigits, '0', STR_PAD_LEFT);

$line = $value . $line;

if ($j === 0) {
                    break;
                }
            }

if ($carry !== 0) {
                $line = $carry . $line;
            }

$line = \ltrim($line, '0');

if ($line !== '') {
                $line .= \str_repeat('0', $x - $blockALength - $i);
                $result = $this->add($result, $line);
            }

if ($i === 0) {
                break;
            }
        }

return $result;
    }

/**
     * Performs the division of two non-signed large integers.
     *
     * @return string[] The quotient and remainder.
     */
    private function doDiv(string $a, string $b) : array
    {
        $cmp = $this->doCmp($a, $b);

if ($cmp === -1) {
            return ['0', $a];
        }

$x = \strlen($a);
        $y = \strlen($b);

// we now know that a >= b && x >= y

$q = '0'; // quotient
        $r = $a; // remainder
        $z = $y; // focus length, always $y or $y+1

for (;;) {
            $focus = \substr($a, 0, $z);

$cmp = $this->doCmp($focus, $b);

if ($cmp === -1) {
                if ($z === $x) { // remainder < dividend
                    break;
                }

$z++;
            }

$zeros = \str_repeat('0', $x - $z);

$q = $this->add($q, '1' . $zeros);
            $a = $this->sub($a, $b . $zeros);

$r = $a;

if ($r === '0') { // remainder == 0
                break;
            }

$x = \strlen($a);

if ($x < $y) { // remainder < dividend
                break;
            }

$z = $y;
        }

return [$q, $r];
    }

/**
     * Compares two non-signed large numbers.
     *
     * @return int [-1, 0, 1]
     */
    private function doCmp(string $a, string $b) : int
    {
        $x = \strlen($a);
        $y = \strlen($b);

$cmp = $x <=> $y;

if ($cmp !== 0) {
            return $cmp;
        }

return \strcmp($a, $b) <=> 0; // enforce [-1, 0, 1]
    }

/**
     * Pads the left of one of the given numbers with zeros if necessary to make both numbers the same length.
     *
     * The numbers must only consist of digits, without leading minus sign.
     *
     * @return array{string, string, int}
     */
    private function pad(string $a, string $b) : array
    {
        $x = \strlen($a);
        $y = \strlen($b);

if ($x > $y) {
            $b = \str_repeat('0', $x - $y) . $b;

return [$a, $b, $x];
        }

if ($x < $y) {
            $a = \str_repeat('0', $y - $x) . $a;

return [$a, $b, $y];
        }

return [$a, $b, $x];
    }
}
���������������������������������������������������������������������������Calculator.php��������������������������������������������������������������������������������������0000644�����������������00000045661�15107326730�0007366 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?php

declare(strict_types=1);

namespace Brick\Math\Internal;

use Brick\Math\Exception\RoundingNecessaryException;
use Brick\Math\RoundingMode;

/**
 * Performs basic operations on arbitrary size integers.
 *
 * Unless otherwise specified, all parameters must be validated as non-empty strings of digits,
 * without leading zero, and with an optional leading minus sign if the number is not zero.
 *
 * Any other parameter format will lead to undefined behaviour.
 * All methods must return strings respecting this format, unless specified otherwise.
 *
 * @internal
 *
 * @psalm-immutable
 */
abstract class Calculator
{
    /**
     * The maximum exponent value allowed for the pow() method.
     */
    public const MAX_POWER = 1000000;

/**
     * The alphabet for converting from and to base 2 to 36, lowercase.
     */
    public const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';

/**
     * The Calculator instance in use.
     */
    private static ?Calculator $instance = null;

/**
     * Sets the Calculator instance to use.
     *
     * An instance is typically set only in unit tests: the autodetect is usually the best option.
     *
     * @param Calculator|null $calculator The calculator instance, or NULL to revert to autodetect.
     */
    final public static function set(?Calculator $calculator) : void
    {
        self::$instance = $calculator;
    }

/**
     * Returns the Calculator instance to use.
     *
     * If none has been explicitly set, the fastest available implementation will be returned.
     *
     * @psalm-pure
     * @psalm-suppress ImpureStaticProperty
     */
    final public static function get() : Calculator
    {
        if (self::$instance === null) {
            /** @psalm-suppress ImpureMethodCall */
            self::$instance = self::detect();
        }

return self::$instance;
    }

/**
     * Returns the fastest available Calculator implementation.
     *
     * @codeCoverageIgnore
     */
    private static function detect() : Calculator
    {
        if (\extension_loaded('gmp')) {
            return new Calculator\GmpCalculator();
        }

if (\extension_loaded('bcmath')) {
            return new Calculator\BcMathCalculator();
        }

return new Calculator\NativeCalculator();
    }

/**
     * Extracts the sign & digits of the operands.
     *
     * @return array{bool, bool, string, string} Whether $a and $b are negative, followed by their digits.
     */
    final protected function init(string $a, string $b) : array
    {
        return [
            $aNeg = ($a[0] === '-'),
            $bNeg = ($b[0] === '-'),

$aNeg ? \substr($a, 1) : $a,
            $bNeg ? \substr($b, 1) : $b,
        ];
    }

/**
     * Returns the absolute value of a number.
     */
    final public function abs(string $n) : string
    {
        return ($n[0] === '-') ? \substr($n, 1) : $n;
    }

/**
     * Negates a number.
     */
    final public function neg(string $n) : string
    {
        if ($n === '0') {
            return '0';
        }

if ($n[0] === '-') {
            return \substr($n, 1);
        }

return '-' . $n;
    }

/**
     * Compares two numbers.
     *
     * @return int [-1, 0, 1] If the first number is less than, equal to, or greater than the second number.
     */
    final public function cmp(string $a, string $b) : int
    {
        [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);

if ($aNeg && ! $bNeg) {
            return -1;
        }

if ($bNeg && ! $aNeg) {
            return 1;
        }

$aLen = \strlen($aDig);
        $bLen = \strlen($bDig);

if ($aLen < $bLen) {
            $result = -1;
        } elseif ($aLen > $bLen) {
            $result = 1;
        } else {
            $result = $aDig <=> $bDig;
        }

return $aNeg ? -$result : $result;
    }

/**
     * Adds two numbers.
     */
    abstract public function add(string $a, string $b) : string;

/**
     * Subtracts two numbers.
     */
    abstract public function sub(string $a, string $b) : string;

/**
     * Multiplies two numbers.
     */
    abstract public function mul(string $a, string $b) : string;

/**
     * Returns the quotient of the division of two numbers.
     *
     * @param string $a The dividend.
     * @param string $b The divisor, must not be zero.
     *
     * @return string The quotient.
     */
    abstract public function divQ(string $a, string $b) : string;

/**
     * Returns the remainder of the division of two numbers.
     *
     * @param string $a The dividend.
     * @param string $b The divisor, must not be zero.
     *
     * @return string The remainder.
     */
    abstract public function divR(string $a, string $b) : string;

/**
     * Returns the quotient and remainder of the division of two numbers.
     *
     * @param string $a The dividend.
     * @param string $b The divisor, must not be zero.
     *
     * @return array{string, string} An array containing the quotient and remainder.
     */
    abstract public function divQR(string $a, string $b) : array;

/**
     * Exponentiates a number.
     *
     * @param string $a The base number.
     * @param int    $e The exponent, validated as an integer between 0 and MAX_POWER.
     *
     * @return string The power.
     */
    abstract public function pow(string $a, int $e) : string;

/**
     * @param string $b The modulus; must not be zero.
     */
    public function mod(string $a, string $b) : string
    {
        return $this->divR($this->add($this->divR($a, $b), $b), $b);
    }

/**
     * Returns the modular multiplicative inverse of $x modulo $m.
     *
     * If $x has no multiplicative inverse mod m, this method must return null.
     *
     * This method can be overridden by the concrete implementation if the underlying library has built-in support.
     *
     * @param string $m The modulus; must not be negative or zero.
     */
    public function modInverse(string $x, string $m) : ?string
    {
        if ($m === '1') {
            return '0';
        }

$modVal = $x;

if ($x[0] === '-' || ($this->cmp($this->abs($x), $m) >= 0)) {
            $modVal = $this->mod($x, $m);
        }

[$g, $x] = $this->gcdExtended($modVal, $m);

if ($g !== '1') {
            return null;
        }

return $this->mod($this->add($this->mod($x, $m), $m), $m);
    }

/**
     * Raises a number into power with modulo.
     *
     * @param string $base The base number; must be positive or zero.
     * @param string $exp  The exponent; must be positive or zero.
     * @param string $mod  The modulus; must be strictly positive.
     */
    abstract public function modPow(string $base, string $exp, string $mod) : string;

/**
     * Returns the greatest common divisor of the two numbers.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for GCD calculations.
     *
     * @return string The GCD, always positive, or zero if both arguments are zero.
     */
    public function gcd(string $a, string $b) : string
    {
        if ($a === '0') {
            return $this->abs($b);
        }

if ($b === '0') {
            return $this->abs($a);
        }

return $this->gcd($b, $this->divR($a, $b));
    }

/**
     * @return array{string, string, string} GCD, X, Y
     */
    private function gcdExtended(string $a, string $b) : array
    {
        if ($a === '0') {
            return [$b, '0', '1'];
        }

[$gcd, $x1, $y1] = $this->gcdExtended($this->mod($b, $a), $a);

$x = $this->sub($y1, $this->mul($this->divQ($b, $a), $x1));
        $y = $x1;

return [$gcd, $x, $y];
    }

/**
     * Returns the square root of the given number, rounded down.
     *
     * The result is the largest x such that x² ≤ n.
     * The input MUST NOT be negative.
     */
    abstract public function sqrt(string $n) : string;

/**
     * Converts a number from an arbitrary base.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for base conversion.
     *
     * @param string $number The number, positive or zero, non-empty, case-insensitively validated for the given base.
     * @param int    $base   The base of the number, validated from 2 to 36.
     *
     * @return string The converted number, following the Calculator conventions.
     */
    public function fromBase(string $number, int $base) : string
    {
        return $this->fromArbitraryBase(\strtolower($number), self::ALPHABET, $base);
    }

/**
     * Converts a number to an arbitrary base.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for base conversion.
     *
     * @param string $number The number to convert, following the Calculator conventions.
     * @param int    $base   The base to convert to, validated from 2 to 36.
     *
     * @return string The converted number, lowercase.
     */
    public function toBase(string $number, int $base) : string
    {
        $negative = ($number[0] === '-');

if ($negative) {
            $number = \substr($number, 1);
        }

$number = $this->toArbitraryBase($number, self::ALPHABET, $base);

if ($negative) {
            return '-' . $number;
        }

return $number;
    }

/**
     * Converts a non-negative number in an arbitrary base using a custom alphabet, to base 10.
     *
     * @param string $number   The number to convert, validated as a non-empty string,
     *                         containing only chars in the given alphabet/base.
     * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum.
     * @param int    $base     The base of the number, validated from 2 to alphabet length.
     *
     * @return string The number in base 10, following the Calculator conventions.
     */
    final public function fromArbitraryBase(string $number, string $alphabet, int $base) : string
    {
        // remove leading "zeros"
        $number = \ltrim($number, $alphabet[0]);

if ($number === '') {
            return '0';
        }

// optimize for "one"
        if ($number === $alphabet[1]) {
            return '1';
        }

$result = '0';
        $power = '1';

$base = (string) $base;

for ($i = \strlen($number) - 1; $i >= 0; $i--) {
            $index = \strpos($alphabet, $number[$i]);

if ($index !== 0) {
                $result = $this->add($result, ($index === 1)
                    ? $power
                    : $this->mul($power, (string) $index)
                );
            }

if ($i !== 0) {
                $power = $this->mul($power, $base);
            }
        }

return $result;
    }

/**
     * Converts a non-negative number to an arbitrary base using a custom alphabet.
     *
     * @param string $number   The number to convert, positive or zero, following the Calculator conventions.
     * @param string $alphabet The alphabet that contains every digit, validated as 2 chars minimum.
     * @param int    $base     The base to convert to, validated from 2 to alphabet length.
     *
     * @return string The converted number in the given alphabet.
     */
    final public function toArbitraryBase(string $number, string $alphabet, int $base) : string
    {
        if ($number === '0') {
            return $alphabet[0];
        }

$base = (string) $base;
        $result = '';

while ($number !== '0') {
            [$number, $remainder] = $this->divQR($number, $base);
            $remainder = (int) $remainder;

$result .= $alphabet[$remainder];
        }

return \strrev($result);
    }

/**
     * Performs a rounded division.
     *
     * Rounding is performed when the remainder of the division is not zero.
     *
     * @param string $a            The dividend.
     * @param string $b            The divisor, must not be zero.
     * @param int    $roundingMode The rounding mode.
     *
     * @throws \InvalidArgumentException  If the rounding mode is invalid.
     * @throws RoundingNecessaryException If RoundingMode::UNNECESSARY is provided but rounding is necessary.
     *
     * @psalm-suppress ImpureFunctionCall
     */
    final public function divRound(string $a, string $b, int $roundingMode) : string
    {
        [$quotient, $remainder] = $this->divQR($a, $b);

$hasDiscardedFraction = ($remainder !== '0');
        $isPositiveOrZero = ($a[0] === '-') === ($b[0] === '-');

$discardedFractionSign = function() use ($remainder, $b) : int {
            $r = $this->abs($this->mul($remainder, '2'));
            $b = $this->abs($b);

return $this->cmp($r, $b);
        };

$increment = false;

switch ($roundingMode) {
            case RoundingMode::UNNECESSARY:
                if ($hasDiscardedFraction) {
                    throw RoundingNecessaryException::roundingNecessary();
                }
                break;

case RoundingMode::UP:
                $increment = $hasDiscardedFraction;
                break;

case RoundingMode::DOWN:
                break;

case RoundingMode::CEILING:
                $increment = $hasDiscardedFraction && $isPositiveOrZero;
                break;

case RoundingMode::FLOOR:
                $increment = $hasDiscardedFraction && ! $isPositiveOrZero;
                break;

case RoundingMode::HALF_UP:
                $increment = $discardedFractionSign() >= 0;
                break;

case RoundingMode::HALF_DOWN:
                $increment = $discardedFractionSign() > 0;
                break;

case RoundingMode::HALF_CEILING:
                $increment = $isPositiveOrZero ? $discardedFractionSign() >= 0 : $discardedFractionSign() > 0;
                break;

case RoundingMode::HALF_FLOOR:
                $increment = $isPositiveOrZero ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0;
                break;

case RoundingMode::HALF_EVEN:
                $lastDigit = (int) $quotient[-1];
                $lastDigitIsEven = ($lastDigit % 2 === 0);
                $increment = $lastDigitIsEven ? $discardedFractionSign() > 0 : $discardedFractionSign() >= 0;
                break;

default:
                throw new \InvalidArgumentException('Invalid rounding mode.');
        }

if ($increment) {
            return $this->add($quotient, $isPositiveOrZero ? '1' : '-1');
        }

return $quotient;
    }

/**
     * Calculates bitwise AND of two numbers.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for bitwise operations.
     */
    public function and(string $a, string $b) : string
    {
        return $this->bitwise('and', $a, $b);
    }

/**
     * Calculates bitwise OR of two numbers.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for bitwise operations.
     */
    public function or(string $a, string $b) : string
    {
        return $this->bitwise('or', $a, $b);
    }

/**
     * Calculates bitwise XOR of two numbers.
     *
     * This method can be overridden by the concrete implementation if the underlying library
     * has built-in support for bitwise operations.
     */
    public function xor(string $a, string $b) : string
    {
        return $this->bitwise('xor', $a, $b);
    }

/**
     * Performs a bitwise operation on a decimal number.
     *
     * @param 'and'|'or'|'xor' $operator The operator to use.
     * @param string           $a        The left operand.
     * @param string           $b        The right operand.
     */
    private function bitwise(string $operator, string $a, string $b) : string
    {
        [$aNeg, $bNeg, $aDig, $bDig] = $this->init($a, $b);

$aBin = $this->toBinary($aDig);
        $bBin = $this->toBinary($bDig);

$aLen = \strlen($aBin);
        $bLen = \strlen($bBin);

if ($aLen > $bLen) {
            $bBin = \str_repeat("\x00", $aLen - $bLen) . $bBin;
        } elseif ($bLen > $aLen) {
            $aBin = \str_repeat("\x00", $bLen - $aLen) . $aBin;
        }

if ($aNeg) {
            $aBin = $this->twosComplement($aBin);
        }
        if ($bNeg) {
            $bBin = $this->twosComplement($bBin);
        }

switch ($operator) {
            case 'and':
                $value = $aBin & $bBin;
                $negative = ($aNeg and $bNeg);
                break;

case 'or':
                $value = $aBin | $bBin;
                $negative = ($aNeg or $bNeg);
                break;

case 'xor':
                $value = $aBin ^ $bBin;
                $negative = ($aNeg xor $bNeg);
                break;

// @codeCoverageIgnoreStart
            default:
                throw new \InvalidArgumentException('Invalid bitwise operator.');
            // @codeCoverageIgnoreEnd
        }

if ($negative) {
            $value = $this->twosComplement($value);
        }

$result = $this->toDecimal($value);

return $negative ? $this->neg($result) : $result;
    }

/**
     * @param string $number A positive, binary number.
     */
    private function twosComplement(string $number) : string
    {
        $xor = \str_repeat("\xff", \strlen($number));

$number ^= $xor;

for ($i = \strlen($number) - 1; $i >= 0; $i--) {
            $byte = \ord($number[$i]);

if (++$byte !== 256) {
                $number[$i] = \chr($byte);
                break;
            }

$number[$i] = "\x00";

if ($i === 0) {
                $number = "\x01" . $number;
            }
        }

return $number;
    }

/**
     * Converts a decimal number to a binary string.
     *
     * @param string $number The number to convert, positive or zero, only digits.
     */
    private function toBinary(string $number) : string
    {
        $result = '';

while ($number !== '0') {
            [$number, $remainder] = $this->divQR($number, '256');
            $result .= \chr((int) $remainder);
        }

return \strrev($result);
    }

/**
     * Returns the positive decimal representation of a binary number.
     *
     * @param string $bytes The bytes representing the number.
     */
    private function toDecimal(string $bytes) : string
    {
        $result = '0';
        $power = '1';

for ($i = \strlen($bytes) - 1; $i >= 0; $i--) {
            $index = \ord($bytes[$i]);

if ($i !== 0) {
                $power = $this->mul($power, '256');
            }
        }

return $result;
    }
}
�������������������������������������������������������������������������������TentativeTypes.php����������������������������������������������������������������������������������0000644�����������������00000163377�15111435222�0010262 0����������������������������������������������������������������������������������������������������ustar�00�������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\ErrorHandler\Internal;

/**
 * This class has been generated by extract-tentative-return-types.php.
 *
 * @internal
 */
class TentativeTypes
{
    public const RETURN_TYPES = [
        'CURLFile' => [
            'getFilename' => 'string',
            'getMimeType' => 'string',
            'getPostFilename' => 'string',
            'setMimeType' => 'void',
            'setPostFilename' => 'void',
        ],
        'DateTimeInterface' => [
            'format' => 'string',
            'getTimezone' => 'DateTimeZone|false',
            'getOffset' => 'int',
            'getTimestamp' => 'int',
            'diff' => 'DateInterval',
            '__wakeup' => 'void',
        ],
        'DateTime' => [
            '__wakeup' => 'void',
            '__set_state' => 'DateTime',
            'createFromImmutable' => 'static',
            'createFromFormat' => 'DateTime|false',
            'getLastErrors' => 'array|false',
            'format' => 'string',
            'modify' => 'DateTime|false',
            'add' => 'DateTime',
            'sub' => 'DateTime',
            'getTimezone' => 'DateTimeZone|false',
            'setTimezone' => 'DateTime',
            'getOffset' => 'int',
            'setTime' => 'DateTime',
            'setDate' => 'DateTime',
            'setISODate' => 'DateTime',
            'setTimestamp' => 'DateTime',
            'getTimestamp' => 'int',
            'diff' => 'DateInterval',
        ],
        'DateTimeImmutable' => [
            '__wakeup' => 'void',
            '__set_state' => 'DateTimeImmutable',
            'createFromFormat' => 'DateTimeImmutable|false',
            'getLastErrors' => 'array|false',
            'format' => 'string',
            'getTimezone' => 'DateTimeZone|false',
            'getOffset' => 'int',
            'getTimestamp' => 'int',
            'diff' => 'DateInterval',
            'modify' => 'DateTimeImmutable|false',
            'add' => 'DateTimeImmutable',
            'sub' => 'DateTimeImmutable',
            'setTimezone' => 'DateTimeImmutable',
            'setTime' => 'DateTimeImmutable',
            'setDate' => 'DateTimeImmutable',
            'setISODate' => 'DateTimeImmutable',
            'setTimestamp' => 'DateTimeImmutable',
            'createFromMutable' => 'static',
        ],
        'DateTimeZone' => [
            'getName' => 'string',
            'getOffset' => 'int',
            'getTransitions' => 'array|false',
            'getLocation' => 'array|false',
            'listAbbreviations' => 'array',
            'listIdentifiers' => 'array',
            '__wakeup' => 'void',
            '__set_state' => 'DateTimeZone',
        ],
        'DateInterval' => [
            'createFromDateString' => 'DateInterval|false',
            'format' => 'string',
            '__wakeup' => 'void',
            '__set_state' => 'DateInterval',
        ],
        'DatePeriod' => [
            'getStartDate' => 'DateTimeInterface',
            'getEndDate' => '?DateTimeInterface',
            'getDateInterval' => 'DateInterval',
            'getRecurrences' => '?int',
            '__wakeup' => 'void',
            '__set_state' => 'DatePeriod',
        ],
        'DOMNode' => [
            'C14N' => 'string|false',
            'C14NFile' => 'int|false',
            'getLineNo' => 'int',
            'getNodePath' => '?string',
            'hasAttributes' => 'bool',
            'hasChildNodes' => 'bool',
            'isDefaultNamespace' => 'bool',
            'isSameNode' => 'bool',
            'isSupported' => 'bool',
            'lookupNamespaceURI' => '?string',
            'lookupPrefix' => '?string',
            'normalize' => 'void',
        ],
        'DOMImplementation' => [
            'getFeature' => 'never',
            'hasFeature' => 'bool',
        ],
        'DOMDocumentFragment' => [
            'appendXML' => 'bool',
        ],
        'DOMNodeList' => [
            'count' => 'int',
        ],
        'DOMCharacterData' => [
            'appendData' => 'bool',
            'insertData' => 'bool',
            'deleteData' => 'bool',
            'replaceData' => 'bool',
        ],
        'DOMAttr' => [
            'isId' => 'bool',
        ],
        'DOMElement' => [
            'getAttribute' => 'string',
            'getAttributeNS' => 'string',
            'getElementsByTagName' => 'DOMNodeList',
            'getElementsByTagNameNS' => 'DOMNodeList',
            'hasAttribute' => 'bool',
            'hasAttributeNS' => 'bool',
            'removeAttribute' => 'bool',
            'removeAttributeNS' => 'void',
            'setAttributeNS' => 'void',
            'setIdAttribute' => 'void',
            'setIdAttributeNS' => 'void',
            'setIdAttributeNode' => 'void',
        ],
        'DOMDocument' => [
            'createComment' => 'DOMComment',
            'createDocumentFragment' => 'DOMDocumentFragment',
            'createTextNode' => 'DOMText',
            'getElementById' => '?DOMElement',
            'getElementsByTagName' => 'DOMNodeList',
            'getElementsByTagNameNS' => 'DOMNodeList',
            'normalizeDocument' => 'void',
            'registerNodeClass' => 'bool',
            'save' => 'int|false',
            'saveHTML' => 'string|false',
            'saveHTMLFile' => 'int|false',
            'saveXML' => 'string|false',
            'schemaValidate' => 'bool',
            'schemaValidateSource' => 'bool',
            'relaxNGValidate' => 'bool',
            'relaxNGValidateSource' => 'bool',
            'validate' => 'bool',
            'xinclude' => 'int|false',
        ],
        'DOMText' => [
            'isWhitespaceInElementContent' => 'bool',
            'isElementContentWhitespace' => 'bool',
        ],
        'DOMNamedNodeMap' => [
            'getNamedItem' => '?DOMNode',
            'getNamedItemNS' => '?DOMNode',
            'item' => '?DOMNode',
            'count' => 'int',
        ],
        'DOMXPath' => [
            'evaluate' => 'mixed',
            'query' => 'mixed',
            'registerNamespace' => 'bool',
            'registerPhpFunctions' => 'void',
        ],
        'finfo' => [
            'file' => 'string|false',
            'buffer' => 'string|false',
        ],
        'IntlPartsIterator' => [
            'getBreakIterator' => 'IntlBreakIterator',
            'getRuleStatus' => 'int',
        ],
        'IntlBreakIterator' => [
            'createCharacterInstance' => '?IntlBreakIterator',
            'createCodePointInstance' => 'IntlCodePointBreakIterator',
            'createLineInstance' => '?IntlBreakIterator',
            'createSentenceInstance' => '?IntlBreakIterator',
            'createTitleInstance' => '?IntlBreakIterator',
            'createWordInstance' => '?IntlBreakIterator',
            'current' => 'int',
            'first' => 'int',
            'following' => 'int',
            'getErrorCode' => 'int',
            'getErrorMessage' => 'string',
            'getLocale' => 'string|false',
            'getPartsIterator' => 'IntlPartsIterator',
            'getText' => '?string',
            'isBoundary' => 'bool',
            'last' => 'int',
            'next' => 'int',
            'preceding' => 'int',
            'previous' => 'int',
            'setText' => '?bool',
        ],
        'IntlRuleBasedBreakIterator' => [
            'getBinaryRules' => 'string|false',
            'getRules' => 'string|false',
            'getRuleStatus' => 'int',
            'getRuleStatusVec' => 'array|false',
        ],
        'IntlCodePointBreakIterator' => [
            'getLastCodePoint' => 'int',
        ],
        'IntlCalendar' => [
            'createInstance' => '?IntlCalendar',
            'equals' => 'bool',
            'fieldDifference' => 'int|false',
            'add' => 'bool',
            'after' => 'bool',
            'before' => 'bool',
            'fromDateTime' => '?IntlCalendar',
            'get' => 'int|false',
            'getActualMaximum' => 'int|false',
            'getActualMinimum' => 'int|false',
            'getAvailableLocales' => 'array',
            'getDayOfWeekType' => 'int|false',
            'getErrorCode' => 'int|false',
            'getErrorMessage' => 'string|false',
            'getFirstDayOfWeek' => 'int|false',
            'getGreatestMinimum' => 'int|false',
            'getKeywordValuesForLocale' => 'IntlIterator|false',
            'getLeastMaximum' => 'int|false',
            'getLocale' => 'string|false',
            'getMaximum' => 'int|false',
            'getMinimalDaysInFirstWeek' => 'int|false',
            'getMinimum' => 'int|false',
            'getNow' => 'float',
            'getRepeatedWallTimeOption' => 'int',
            'getSkippedWallTimeOption' => 'int',
            'getTime' => 'float|false',
            'getTimeZone' => 'IntlTimeZone|false',
            'getType' => 'string',
            'getWeekendTransition' => 'int|false',
            'inDaylightTime' => 'bool',
            'isEquivalentTo' => 'bool',
            'isLenient' => 'bool',
            'isWeekend' => 'bool',
            'roll' => 'bool',
            'isSet' => 'bool',
            'setTime' => 'bool',
            'setTimeZone' => 'bool',
            'toDateTime' => 'DateTime|false',
        ],
        'IntlGregorianCalendar' => [
            'setGregorianChange' => 'bool',
            'getGregorianChange' => 'float',
            'isLeapYear' => 'bool',
        ],
        'Collator' => [
            'create' => '?Collator',
            'compare' => 'int|false',
            'sort' => 'bool',
            'sortWithSortKeys' => 'bool',
            'asort' => 'bool',
            'getAttribute' => 'int|false',
            'setAttribute' => 'bool',
            'getStrength' => 'int',
            'getLocale' => 'string|false',
            'getErrorCode' => 'int|false',
            'getErrorMessage' => 'string|false',
            'getSortKey' => 'string|false',
        ],
        'IntlIterator' => [
            'current' => 'mixed',
            'key' => 'mixed',
            'next' => 'void',
            'rewind' => 'void',
            'valid' => 'bool',
        ],
        'UConverter' => [
            'convert' => 'string|false',
            'fromUCallback' => 'string|int|array|null',
            'getAliases' => 'array|false|null',
            'getAvailable' => 'array',
            'getDestinationEncoding' => 'string|false|null',
            'getDestinationType' => 'int|false|null',
            'getErrorCode' => 'int',
            'getErrorMessage' => '?string',
            'getSourceEncoding' => 'string|false|null',
            'getSourceType' => 'int|false|null',
            'getStandards' => '?array',
            'getSubstChars' => 'string|false|null',
            'reasonText' => 'string',
            'setDestinationEncoding' => 'bool',
            'setSourceEncoding' => 'bool',
            'setSubstChars' => 'bool',
            'toUCallback' => 'string|int|array|null',
            'transcode' => 'string|false',
        ],
        'IntlDateFormatter' => [
            'create' => '?IntlDateFormatter',
            'getDateType' => 'int|false',
            'getTimeType' => 'int|false',
            'getCalendar' => 'int|false',
            'setCalendar' => 'bool',
            'getTimeZoneId' => 'string|false',
            'getCalendarObject' => 'IntlCalendar|false|null',
            'getTimeZone' => 'IntlTimeZone|false',
            'setTimeZone' => '?bool',
            'setPattern' => 'bool',
            'getPattern' => 'string|false',
            'getLocale' => 'string|false',
            'setLenient' => 'void',
            'isLenient' => 'bool',
            'format' => 'string|false',
            'formatObject' => 'string|false',
            'parse' => 'int|float|false',
            'localtime' => 'array|false',
            'getErrorCode' => 'int',
            'getErrorMessage' => 'string',
        ],
        'NumberFormatter' => [
            'create' => '?NumberFormatter',
            'format' => 'string|false',
            'parse' => 'int|float|false',
            'formatCurrency' => 'string|false',
            'parseCurrency' => 'float|false',
            'setAttribute' => 'bool',
            'getAttribute' => 'int|float|false',
            'setTextAttribute' => 'bool',
            'getTextAttribute' => 'string|false',
            'setSymbol' => 'bool',
            'getSymbol' => 'string|false',
            'setPattern' => 'bool',
            'getPattern' => 'string|false',
            'getLocale' => 'string|false',
            'getErrorCode' => 'int',
            'getErrorMessage' => 'string',
        ],
        'Locale' => [
            'getDefault' => 'string',
            'getPrimaryLanguage' => '?string',
            'getScript' => '?string',
            'getRegion' => '?string',
            'getKeywords' => 'array|false|null',
            'getDisplayScript' => 'string|false',
            'getDisplayRegion' => 'string|false',
            'getDisplayName' => 'string|false',
            'getDisplayLanguage' => 'string|false',
            'getDisplayVariant' => 'string|false',
            'composeLocale' => 'string|false',
            'parseLocale' => '?array',
            'getAllVariants' => '?array',
            'filterMatches' => '?bool',
            'lookup' => '?string',
            'canonicalize' => '?string',
            'acceptFromHttp' => 'string|false',
        ],
        'MessageFormatter' => [
            'create' => '?MessageFormatter',
            'format' => 'string|false',
            'formatMessage' => 'string|false',
            'parse' => 'array|false',
            'parseMessage' => 'array|false',
            'setPattern' => 'bool',
            'getPattern' => 'string|false',
            'getLocale' => 'string',
            'getErrorCode' => 'int',
            'getErrorMessage' => 'string',
        ],
        'Normalizer' => [
            'normalize' => 'string|false',
            'isNormalized' => 'bool',
            'getRawDecomposition' => '?string',
        ],
        'ResourceBundle' => [
            'create' => '?ResourceBundle',
            'get' => 'mixed',
            'count' => 'int',
            'getLocales' => 'array|false',
            'getErrorCode' => 'int',
            'getErrorMessage' => 'string',
        ],
        'Spoofchecker' => [
            'isSuspicious' => 'bool',
            'areConfusable' => 'bool',
            'setAllowedLocales' => 'void',
            'setChecks' => 'void',
            'setRestrictionLevel' => 'void',
        ],
        'IntlTimeZone' => [
            'countEquivalentIDs' => 'int|false',
            'createDefault' => 'IntlTimeZone',
            'createEnumeration' => 'IntlIterator|false',
            'createTimeZone' => '?IntlTimeZone',
            'createTimeZoneIDEnumeration' => 'IntlIterator|false',
            'fromDateTimeZone' => '?IntlTimeZone',
            'getCanonicalID' => 'string|false',
            'getDisplayName' => 'string|false',
            'getDSTSavings' => 'int',
            'getEquivalentID' => 'string|false',
            'getErrorCode' => 'int|false',
            'getErrorMessage' => 'string|false',
            'getGMT' => 'IntlTimeZone',
            'getID' => 'string|false',
            'getOffset' => 'bool',
            'getRawOffset' => 'int',
            'getRegion' => 'string|false',
            'getTZDataVersion' => 'string|false',
            'getUnknown' => 'IntlTimeZone',
            'getWindowsID' => 'string|false',
            'getIDForWindowsID' => 'string|false',
            'hasSameRules' => 'bool',
            'toDateTimeZone' => 'DateTimeZone|false',
            'useDaylightTime' => 'bool',
        ],
        'Transliterator' => [
            'create' => '?Transliterator',
            'createFromRules' => '?Transliterator',
            'createInverse' => '?Transliterator',
            'listIDs' => 'array|false',
            'transliterate' => 'string|false',
            'getErrorCode' => 'int|false',
            'getErrorMessage' => 'string|false',
        ],
        'IntlChar' => [
            'hasBinaryProperty' => '?bool',
            'charAge' => '?array',
            'charDigitValue' => '?int',
            'charDirection' => '?int',
            'charFromName' => '?int',
            'charMirror' => 'int|string|null',
            'charName' => '?string',
            'charType' => '?int',
            'chr' => '?string',
            'digit' => 'int|false|null',
            'enumCharNames' => '?bool',
            'enumCharTypes' => 'void',
            'foldCase' => 'int|string|null',
            'forDigit' => 'int',
            'getBidiPairedBracket' => 'int|string|null',
            'getBlockCode' => '?int',
            'getCombiningClass' => '?int',
            'getFC_NFKC_Closure' => 'string|false|null',
            'getIntPropertyMaxValue' => 'int',
            'getIntPropertyMinValue' => 'int',
            'getIntPropertyValue' => '?int',
            'getNumericValue' => '?float',
            'getPropertyEnum' => 'int',
            'getPropertyName' => 'string|false',
            'getPropertyValueEnum' => 'int',
            'getPropertyValueName' => 'string|false',
            'getUnicodeVersion' => 'array',
            'isalnum' => '?bool',
            'isalpha' => '?bool',
            'isbase' => '?bool',
            'isblank' => '?bool',
            'iscntrl' => '?bool',
            'isdefined' => '?bool',
            'isdigit' => '?bool',
            'isgraph' => '?bool',
            'isIDIgnorable' => '?bool',
            'isIDPart' => '?bool',
            'isIDStart' => '?bool',
            'isISOControl' => '?bool',
            'isJavaIDPart' => '?bool',
            'isJavaIDStart' => '?bool',
            'isJavaSpaceChar' => '?bool',
            'islower' => '?bool',
            'isMirrored' => '?bool',
            'isprint' => '?bool',
            'ispunct' => '?bool',
            'isspace' => '?bool',
            'istitle' => '?bool',
            'isUAlphabetic' => '?bool',
            'isULowercase' => '?bool',
            'isupper' => '?bool',
            'isUUppercase' => '?bool',
            'isUWhiteSpace' => '?bool',
            'isWhitespace' => '?bool',
            'isxdigit' => '?bool',
            'ord' => '?int',
            'tolower' => 'int|string|null',
            'totitle' => 'int|string|null',
            'toupper' => 'int|string|null',
        ],
        'JsonSerializable' => [
            'jsonSerialize' => 'mixed',
        ],
        'mysqli' => [
            'autocommit' => 'bool',
            'begin_transaction' => 'bool',
            'change_user' => 'bool',
            'character_set_name' => 'string',
            'commit' => 'bool',
            'connect' => 'bool',
            'dump_debug_info' => 'bool',
            'get_charset' => '?object',
            'get_client_info' => 'string',
            'get_connection_stats' => 'array',
            'get_server_info' => 'string',
            'get_warnings' => 'mysqli_warning|false',
            'kill' => 'bool',
            'multi_query' => 'bool',
            'more_results' => 'bool',
            'next_result' => 'bool',
            'ping' => 'bool',
            'poll' => 'int|false',
            'prepare' => 'mysqli_stmt|false',
            'query' => 'mysqli_result|bool',
            'real_connect' => 'bool',
            'real_escape_string' => 'string',
            'reap_async_query' => 'mysqli_result|bool',
            'escape_string' => 'string',
            'real_query' => 'bool',
            'release_savepoint' => 'bool',
            'rollback' => 'bool',
            'savepoint' => 'bool',
            'select_db' => 'bool',
            'set_charset' => 'bool',
            'options' => 'bool',
            'set_opt' => 'bool',
            'stat' => 'string|false',
            'stmt_init' => 'mysqli_stmt|false',
            'store_result' => 'mysqli_result|false',
            'thread_safe' => 'bool',
            'use_result' => 'mysqli_result|false',
            'refresh' => 'bool',
        ],
        'mysqli_result' => [
            'close' => 'void',
            'free' => 'void',
            'data_seek' => 'bool',
            'fetch_field' => 'object|false',
            'fetch_fields' => 'array',
            'fetch_field_direct' => 'object|false',
            'fetch_all' => 'array',
            'fetch_array' => 'array|null|false',
            'fetch_assoc' => 'array|null|false',
            'fetch_object' => 'object|null|false',
            'fetch_row' => 'array|null|false',
            'field_seek' => 'bool',
            'free_result' => 'void',
        ],
        'mysqli_stmt' => [
            'attr_get' => 'int',
            'attr_set' => 'bool',
            'bind_param' => 'bool',
            'bind_result' => 'bool',
            'data_seek' => 'void',
            'execute' => 'bool',
            'fetch' => '?bool',
            'get_warnings' => 'mysqli_warning|false',
            'result_metadata' => 'mysqli_result|false',
            'more_results' => 'bool',
            'next_result' => 'bool',
            'num_rows' => 'int|string',
            'send_long_data' => 'bool',
            'free_result' => 'void',
            'reset' => 'bool',
            'prepare' => 'bool',
            'store_result' => 'bool',
            'get_result' => 'mysqli_result|false',
        ],
        'OCILob' => [
            'save' => 'bool',
            'import' => 'bool',
            'saveFile' => 'bool',
            'load' => 'string|false',
            'read' => 'string|false',
            'eof' => 'bool',
            'tell' => 'int|false',
            'rewind' => 'bool',
            'seek' => 'bool',
            'size' => 'int|false',
            'write' => 'int|false',
            'append' => 'bool',
            'truncate' => 'bool',
            'erase' => 'int|false',
            'flush' => 'bool',
            'setBuffering' => 'bool',
            'getBuffering' => 'bool',
            'writeToFile' => 'bool',
            'export' => 'bool',
            'writeTemporary' => 'bool',
            'close' => 'bool',
            'free' => 'bool',
        ],
        'OCICollection' => [
            'free' => 'bool',
            'append' => 'bool',
            'getElem' => 'string|float|null|false',
            'assign' => 'bool',
            'assignElem' => 'bool',
            'size' => 'int|false',
            'max' => 'int|false',
            'trim' => 'bool',
        ],
        'PDO' => [
            'beginTransaction' => 'bool',
            'commit' => 'bool',
            'errorCode' => '?string',
            'errorInfo' => 'array',
            'exec' => 'int|false',
            'getAttribute' => 'mixed',
            'getAvailableDrivers' => 'array',
            'inTransaction' => 'bool',
            'lastInsertId' => 'string|false',
            'prepare' => 'PDOStatement|false',
            'query' => 'PDOStatement|false',
            'quote' => 'string|false',
            'rollBack' => 'bool',
            'setAttribute' => 'bool',
        ],
        'PDOStatement' => [
            'bindColumn' => 'bool',
            'bindParam' => 'bool',
            'bindValue' => 'bool',
            'closeCursor' => 'bool',
            'columnCount' => 'int',
            'debugDumpParams' => '?bool',
            'errorCode' => '?string',
            'errorInfo' => 'array',
            'execute' => 'bool',
            'fetch' => 'mixed',
            'fetchAll' => 'array',
            'fetchColumn' => 'mixed',
            'fetchObject' => 'object|false',
            'getAttribute' => 'mixed',
            'getColumnMeta' => 'array|false',
            'nextRowset' => 'bool',
            'rowCount' => 'int',
            'setAttribute' => 'bool',
        ],
        'PDO_PGSql_Ext' => [
            'pgsqlCopyFromArray' => 'bool',
            'pgsqlCopyFromFile' => 'bool',
            'pgsqlCopyToArray' => 'array|false',
            'pgsqlCopyToFile' => 'bool',
            'pgsqlLOBCreate' => 'string|false',
            'pgsqlLOBUnlink' => 'bool',
            'pgsqlGetNotify' => 'array|false',
            'pgsqlGetPid' => 'int',
        ],
        'PDO_SQLite_Ext' => [
            'sqliteCreateFunction' => 'bool',
            'sqliteCreateAggregate' => 'bool',
            'sqliteCreateCollation' => 'bool',
        ],
        'Phar' => [
            'addEmptyDir' => 'void',
            'addFile' => 'void',
            'addFromString' => 'void',
            'buildFromDirectory' => 'array',
            'buildFromIterator' => 'array',
            'compressFiles' => 'void',
            'compress' => '?Phar',
            'decompress' => '?Phar',
            'convertToExecutable' => '?Phar',
            'convertToData' => '?PharData',
            'count' => 'int',
            'extractTo' => 'bool',
            'getAlias' => '?string',
            'getPath' => 'string',
            'getMetadata' => 'mixed',
            'getModified' => 'bool',
            'getSignature' => 'array|false',
            'getStub' => 'string',
            'getVersion' => 'string',
            'hasMetadata' => 'bool',
            'isBuffering' => 'bool',
            'isCompressed' => 'int|false',
            'isFileFormat' => 'bool',
            'isWritable' => 'bool',
            'offsetExists' => 'bool',
            'offsetGet' => 'SplFileInfo',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'setAlias' => 'bool',
            'setDefaultStub' => 'bool',
            'setMetadata' => 'void',
            'setSignatureAlgorithm' => 'void',
            'startBuffering' => 'void',
            'stopBuffering' => 'void',
        ],
        'PharData' => [
            'addEmptyDir' => 'void',
            'addFile' => 'void',
            'addFromString' => 'void',
            'buildFromDirectory' => 'array',
            'buildFromIterator' => 'array',
            'compressFiles' => 'void',
            'compress' => '?PharData',
            'decompress' => '?PharData',
            'convertToExecutable' => '?Phar',
            'convertToData' => '?PharData',
            'count' => 'int',
            'extractTo' => 'bool',
            'getAlias' => '?string',
            'getPath' => 'string',
            'getMetadata' => 'mixed',
            'getModified' => 'bool',
            'getSignature' => 'array|false',
            'getStub' => 'string',
            'getVersion' => 'string',
            'hasMetadata' => 'bool',
            'isBuffering' => 'bool',
            'isCompressed' => 'int|false',
            'isFileFormat' => 'bool',
            'isWritable' => 'bool',
            'offsetExists' => 'bool',
            'offsetGet' => 'SplFileInfo',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'setAlias' => 'bool',
            'setDefaultStub' => 'bool',
            'setMetadata' => 'void',
            'setSignatureAlgorithm' => 'void',
            'startBuffering' => 'void',
            'stopBuffering' => 'void',
        ],
        'PharFileInfo' => [
            'chmod' => 'void',
            'getCompressedSize' => 'int',
            'getCRC32' => 'int',
            'getContent' => 'string',
            'getMetadata' => 'mixed',
            'getPharFlags' => 'int',
            'hasMetadata' => 'bool',
            'isCompressed' => 'bool',
            'isCRCChecked' => 'bool',
            'setMetadata' => 'void',
        ],
        'Reflection' => [
            'getModifierNames' => 'array',
        ],
        'ReflectionFunctionAbstract' => [
            'inNamespace' => 'bool',
            'isClosure' => 'bool',
            'isDeprecated' => 'bool',
            'isInternal' => 'bool',
            'isUserDefined' => 'bool',
            'isGenerator' => 'bool',
            'isVariadic' => 'bool',
            'isStatic' => 'bool',
            'getClosureThis' => '?object',
            'getClosureCalledClass' => '?ReflectionClass',
            'getClosureScopeClass' => '?ReflectionClass',
            'getDocComment' => 'string|false',
            'getEndLine' => 'int|false',
            'getExtension' => '?ReflectionExtension',
            'getExtensionName' => 'string|false',
            'getFileName' => 'string|false',
            'getName' => 'string',
            'getNamespaceName' => 'string',
            'getNumberOfParameters' => 'int',
            'getNumberOfRequiredParameters' => 'int',
            'getParameters' => 'array',
            'getShortName' => 'string',
            'getStartLine' => 'int|false',
            'getStaticVariables' => 'array',
            'returnsReference' => 'bool',
            'hasReturnType' => 'bool',
            'getReturnType' => '?ReflectionType',
        ],
        'ReflectionFunction' => [
            'isDisabled' => 'bool',
            'invoke' => 'mixed',
            'invokeArgs' => 'mixed',
            'getClosure' => 'Closure',
            'getExecutingLine' => 'int',
            'getExecutingFile' => 'string',
            'getTrace' => 'array',
            'getFunction' => 'ReflectionFunctionAbstract',
            'getThis' => '?object',
            'getExecutingGenerator' => 'Generator',
        ],
        'ReflectionMethod' => [
            'isPublic' => 'bool',
            'isPrivate' => 'bool',
            'isProtected' => 'bool',
            'isAbstract' => 'bool',
            'isFinal' => 'bool',
            'isConstructor' => 'bool',
            'isDestructor' => 'bool',
            'getClosure' => 'Closure',
            'getModifiers' => 'int',
            'invoke' => 'mixed',
            'invokeArgs' => 'mixed',
            'getDeclaringClass' => 'ReflectionClass',
            'getPrototype' => 'ReflectionMethod',
            'setAccessible' => 'void',
        ],
        'ReflectionClass' => [
            'getName' => 'string',
            'isInternal' => 'bool',
            'isUserDefined' => 'bool',
            'isAnonymous' => 'bool',
            'isInstantiable' => 'bool',
            'isCloneable' => 'bool',
            'getFileName' => 'string|false',
            'getStartLine' => 'int|false',
            'getEndLine' => 'int|false',
            'getDocComment' => 'string|false',
            'getConstructor' => '?ReflectionMethod',
            'hasMethod' => 'bool',
            'getMethod' => 'ReflectionMethod',
            'getMethods' => 'array',
            'hasProperty' => 'bool',
            'getProperty' => 'ReflectionProperty',
            'getProperties' => 'array',
            'hasConstant' => 'bool',
            'getConstants' => 'array',
            'getReflectionConstants' => 'array',
            'getConstant' => 'mixed',
            'getReflectionConstant' => 'ReflectionClassConstant|false',
            'getInterfaces' => 'array',
            'getInterfaceNames' => 'array',
            'isInterface' => 'bool',
            'getTraits' => 'array',
            'getTraitNames' => 'array',
            'getTraitAliases' => 'array',
            'isTrait' => 'bool',
            'isAbstract' => 'bool',
            'isFinal' => 'bool',
            'getModifiers' => 'int',
            'isInstance' => 'bool',
            'newInstance' => 'object',
            'newInstanceWithoutConstructor' => 'object',
            'newInstanceArgs' => '?object',
            'getParentClass' => 'ReflectionClass|false',
            'isSubclassOf' => 'bool',
            'getStaticProperties' => '?array',
            'getStaticPropertyValue' => 'mixed',
            'setStaticPropertyValue' => 'void',
            'getDefaultProperties' => 'array',
            'isIterable' => 'bool',
            'isIterateable' => 'bool',
            'implementsInterface' => 'bool',
            'getExtension' => '?ReflectionExtension',
            'getExtensionName' => 'string|false',
            'inNamespace' => 'bool',
            'getNamespaceName' => 'string',
            'getShortName' => 'string',
        ],
        'ReflectionProperty' => [
            'getName' => 'string',
            'getValue' => 'mixed',
            'setValue' => 'void',
            'isInitialized' => 'bool',
            'isPublic' => 'bool',
            'isPrivate' => 'bool',
            'isProtected' => 'bool',
            'isStatic' => 'bool',
            'isDefault' => 'bool',
            'getModifiers' => 'int',
            'getDeclaringClass' => 'ReflectionClass',
            'getDocComment' => 'string|false',
            'setAccessible' => 'void',
            'getType' => '?ReflectionType',
            'hasType' => 'bool',
            'getDefaultValue' => 'mixed',
        ],
        'ReflectionClassConstant' => [
            'getName' => 'string',
            'getValue' => 'mixed',
            'isPublic' => 'bool',
            'isPrivate' => 'bool',
            'isProtected' => 'bool',
            'getModifiers' => 'int',
            'getDeclaringClass' => 'ReflectionClass',
            'getDocComment' => 'string|false',
        ],
        'ReflectionParameter' => [
            'getName' => 'string',
            'isPassedByReference' => 'bool',
            'canBePassedByValue' => 'bool',
            'getDeclaringFunction' => 'ReflectionFunctionAbstract',
            'getDeclaringClass' => '?ReflectionClass',
            'getClass' => '?ReflectionClass',
            'hasType' => 'bool',
            'getType' => '?ReflectionType',
            'isArray' => 'bool',
            'isCallable' => 'bool',
            'allowsNull' => 'bool',
            'getPosition' => 'int',
            'isOptional' => 'bool',
            'isDefaultValueAvailable' => 'bool',
            'getDefaultValue' => 'mixed',
            'isDefaultValueConstant' => 'bool',
            'getDefaultValueConstantName' => '?string',
            'isVariadic' => 'bool',
        ],
        'ReflectionType' => [
            'allowsNull' => 'bool',
        ],
        'ReflectionNamedType' => [
            'getName' => 'string',
            'isBuiltin' => 'bool',
        ],
        'ReflectionExtension' => [
            'getName' => 'string',
            'getVersion' => '?string',
            'getFunctions' => 'array',
            'getConstants' => 'array',
            'getINIEntries' => 'array',
            'getClasses' => 'array',
            'getClassNames' => 'array',
            'getDependencies' => 'array',
            'info' => 'void',
            'isPersistent' => 'bool',
            'isTemporary' => 'bool',
        ],
        'ReflectionZendExtension' => [
            'getName' => 'string',
            'getVersion' => 'string',
            'getAuthor' => 'string',
            'getURL' => 'string',
            'getCopyright' => 'string',
        ],
        'SessionHandlerInterface' => [
            'open' => 'bool',
            'close' => 'bool',
            'read' => 'string|false',
            'write' => 'bool',
            'destroy' => 'bool',
            'gc' => 'int|false',
        ],
        'SessionIdInterface' => [
            'create_sid' => 'string',
        ],
        'SessionUpdateTimestampHandlerInterface' => [
            'validateId' => 'bool',
            'updateTimestamp' => 'bool',
        ],
        'SessionHandler' => [
            'open' => 'bool',
            'close' => 'bool',
            'read' => 'string|false',
            'write' => 'bool',
            'destroy' => 'bool',
            'gc' => 'int|false',
            'create_sid' => 'string',
        ],
        'SimpleXMLElement' => [
            'xpath' => 'array|null|false',
            'registerXPathNamespace' => 'bool',
            'asXML' => 'string|bool',
            'saveXML' => 'string|bool',
            'getNamespaces' => 'array',
            'getDocNamespaces' => 'array|false',
            'children' => '?SimpleXMLElement',
            'attributes' => '?SimpleXMLElement',
            'addChild' => '?SimpleXMLElement',
            'addAttribute' => 'void',
            'getName' => 'string',
            'count' => 'int',
            'rewind' => 'void',
            'valid' => 'bool',
            'current' => 'SimpleXMLElement',
            'key' => 'string',
            'next' => 'void',
            'hasChildren' => 'bool',
            'getChildren' => '?SimpleXMLElement',
        ],
        'SNMP' => [
            'close' => 'bool',
            'setSecurity' => 'bool',
            'get' => 'mixed',
            'getnext' => 'mixed',
            'walk' => 'array|false',
            'set' => 'bool',
            'getErrno' => 'int',
            'getError' => 'string',
        ],
        'SoapServer' => [
            'fault' => 'void',
            'addSoapHeader' => 'void',
            'setPersistence' => 'void',
            'setClass' => 'void',
            'setObject' => 'void',
            'getFunctions' => 'array',
            'addFunction' => 'void',
            'handle' => 'void',
        ],
        'SoapClient' => [
            '__call' => 'mixed',
            '__soapCall' => 'mixed',
            '__getFunctions' => '?array',
            '__getTypes' => '?array',
            '__getLastRequest' => '?string',
            '__getLastResponse' => '?string',
            '__getLastRequestHeaders' => '?string',
            '__getLastResponseHeaders' => '?string',
            '__doRequest' => '?string',
            '__setCookie' => 'void',
            '__getCookies' => 'array',
            '__setSoapHeaders' => 'bool',
            '__setLocation' => '?string',
        ],
        'ArrayObject' => [
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'append' => 'void',
            'getArrayCopy' => 'array',
            'count' => 'int',
            'getFlags' => 'int',
            'setFlags' => 'void',
            'asort' => 'bool',
            'ksort' => 'bool',
            'uasort' => 'bool',
            'uksort' => 'bool',
            'natsort' => 'bool',
            'natcasesort' => 'bool',
            'unserialize' => 'void',
            'serialize' => 'string',
            '__serialize' => 'array',
            '__unserialize' => 'void',
            'getIterator' => 'Iterator',
            'exchangeArray' => 'array',
            'setIteratorClass' => 'void',
            'getIteratorClass' => 'string',
            '__debugInfo' => 'array',
        ],
        'ArrayIterator' => [
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'append' => 'void',
            'getArrayCopy' => 'array',
            'count' => 'int',
            'getFlags' => 'int',
            'setFlags' => 'void',
            'asort' => 'bool',
            'ksort' => 'bool',
            'uasort' => 'bool',
            'uksort' => 'bool',
            'natsort' => 'bool',
            'natcasesort' => 'bool',
            'unserialize' => 'void',
            'serialize' => 'string',
            '__serialize' => 'array',
            '__unserialize' => 'void',
            'rewind' => 'void',
            'current' => 'mixed',
            'key' => 'string|int|null',
            'next' => 'void',
            'valid' => 'bool',
            'seek' => 'void',
            '__debugInfo' => 'array',
        ],
        'RecursiveArrayIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => '?RecursiveArrayIterator',
        ],
        'SplFileInfo' => [
            'getPath' => 'string',
            'getFilename' => 'string',
            'getExtension' => 'string',
            'getBasename' => 'string',
            'getPathname' => 'string',
            'getPerms' => 'int|false',
            'getInode' => 'int|false',
            'getSize' => 'int|false',
            'getOwner' => 'int|false',
            'getGroup' => 'int|false',
            'getATime' => 'int|false',
            'getMTime' => 'int|false',
            'getCTime' => 'int|false',
            'getType' => 'string|false',
            'isWritable' => 'bool',
            'isReadable' => 'bool',
            'isExecutable' => 'bool',
            'isFile' => 'bool',
            'isDir' => 'bool',
            'isLink' => 'bool',
            'getLinkTarget' => 'string|false',
            'getRealPath' => 'string|false',
            'getFileInfo' => 'SplFileInfo',
            'getPathInfo' => '?SplFileInfo',
            'openFile' => 'SplFileObject',
            'setFileClass' => 'void',
            'setInfoClass' => 'void',
            '__debugInfo' => 'array',
            '_bad_state_ex' => 'void',
        ],
        'DirectoryIterator' => [
            'getFilename' => 'string',
            'getExtension' => 'string',
            'getBasename' => 'string',
            'isDot' => 'bool',
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'mixed',
            'current' => 'mixed',
            'next' => 'void',
            'seek' => 'void',
        ],
        'FilesystemIterator' => [
            'rewind' => 'void',
            'key' => 'string',
            'current' => 'string|SplFileInfo|FilesystemIterator',
            'getFlags' => 'int',
            'setFlags' => 'void',
        ],
        'RecursiveDirectoryIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => 'RecursiveDirectoryIterator',
            'getSubPath' => 'string',
            'getSubPathname' => 'string',
        ],
        'GlobIterator' => [
            'count' => 'int',
        ],
        'SplFileObject' => [
            'rewind' => 'void',
            'eof' => 'bool',
            'valid' => 'bool',
            'fgets' => 'string',
            'fread' => 'string|false',
            'fgetcsv' => 'array|false',
            'fputcsv' => 'int|false',
            'setCsvControl' => 'void',
            'getCsvControl' => 'array',
            'flock' => 'bool',
            'fflush' => 'bool',
            'ftell' => 'int|false',
            'fseek' => 'int',
            'fgetc' => 'string|false',
            'fpassthru' => 'int',
            'fscanf' => 'array|int|null',
            'fwrite' => 'int|false',
            'fstat' => 'array',
            'ftruncate' => 'bool',
            'current' => 'string|array|false',
            'key' => 'int',
            'next' => 'void',
            'setFlags' => 'void',
            'getFlags' => 'int',
            'setMaxLineLen' => 'void',
            'getMaxLineLen' => 'int',
            'hasChildren' => 'false',
            'getChildren' => 'null',
            'seek' => 'void',
            'getCurrentLine' => 'string',
        ],
        'SplDoublyLinkedList' => [
            'add' => 'void',
            'pop' => 'mixed',
            'shift' => 'mixed',
            'push' => 'void',
            'unshift' => 'void',
            'top' => 'mixed',
            'bottom' => 'mixed',
            '__debugInfo' => 'array',
            'count' => 'int',
            'isEmpty' => 'bool',
            'setIteratorMode' => 'int',
            'getIteratorMode' => 'int',
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'rewind' => 'void',
            'current' => 'mixed',
            'key' => 'int',
            'prev' => 'void',
            'next' => 'void',
            'valid' => 'bool',
            'unserialize' => 'void',
            'serialize' => 'string',
            '__serialize' => 'array',
            '__unserialize' => 'void',
        ],
        'SplQueue' => [
            'enqueue' => 'void',
            'dequeue' => 'mixed',
        ],
        'SplFixedArray' => [
            '__wakeup' => 'void',
            'count' => 'int',
            'toArray' => 'array',
            'fromArray' => 'SplFixedArray',
            'getSize' => 'int',
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
        ],
        'SplPriorityQueue' => [
            'compare' => 'int',
            'setExtractFlags' => 'int',
            'top' => 'mixed',
            'extract' => 'mixed',
            'count' => 'int',
            'isEmpty' => 'bool',
            'rewind' => 'void',
            'current' => 'mixed',
            'key' => 'int',
            'next' => 'void',
            'valid' => 'bool',
            'isCorrupted' => 'bool',
            'getExtractFlags' => 'int',
            '__debugInfo' => 'array',
        ],
        'SplHeap' => [
            'extract' => 'mixed',
            'insert' => 'bool',
            'top' => 'mixed',
            'count' => 'int',
            'isEmpty' => 'bool',
            'rewind' => 'void',
            'current' => 'mixed',
            'key' => 'int',
            'next' => 'void',
            'valid' => 'bool',
            'recoverFromCorruption' => 'bool',
            'compare' => 'int',
            'isCorrupted' => 'bool',
            '__debugInfo' => 'array',
        ],
        'SplMinHeap' => [
            'compare' => 'int',
        ],
        'SplMaxHeap' => [
            'compare' => 'int',
        ],
        'EmptyIterator' => [
            'current' => 'never',
            'next' => 'void',
            'key' => 'never',
            'valid' => 'false',
            'rewind' => 'void',
        ],
        'CallbackFilterIterator' => [
            'accept' => 'bool',
        ],
        'RecursiveCallbackFilterIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => 'RecursiveCallbackFilterIterator',
        ],
        'RecursiveIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => '?RecursiveIterator',
        ],
        'RecursiveIteratorIterator' => [
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'mixed',
            'current' => 'mixed',
            'next' => 'void',
            'getDepth' => 'int',
            'getSubIterator' => '?RecursiveIterator',
            'getInnerIterator' => 'RecursiveIterator',
            'beginIteration' => 'void',
            'endIteration' => 'void',
            'callHasChildren' => 'bool',
            'callGetChildren' => '?RecursiveIterator',
            'beginChildren' => 'void',
            'endChildren' => 'void',
            'nextElement' => 'void',
            'setMaxDepth' => 'void',
            'getMaxDepth' => 'int|false',
        ],
        'OuterIterator' => [
            'getInnerIterator' => '?Iterator',
        ],
        'IteratorIterator' => [
            'getInnerIterator' => '?Iterator',
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'mixed',
            'current' => 'mixed',
            'next' => 'void',
        ],
        'FilterIterator' => [
            'accept' => 'bool',
            'rewind' => 'void',
            'next' => 'void',
        ],
        'RecursiveFilterIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => '?RecursiveFilterIterator',
        ],
        'ParentIterator' => [
            'accept' => 'bool',
        ],
        'SeekableIterator' => [
            'seek' => 'void',
        ],
        'LimitIterator' => [
            'rewind' => 'void',
            'valid' => 'bool',
            'next' => 'void',
            'seek' => 'int',
            'getPosition' => 'int',
        ],
        'CachingIterator' => [
            'rewind' => 'void',
            'valid' => 'bool',
            'next' => 'void',
            'hasNext' => 'bool',
            'getFlags' => 'int',
            'setFlags' => 'void',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'offsetExists' => 'bool',
            'getCache' => 'array',
            'count' => 'int',
        ],
        'RecursiveCachingIterator' => [
            'hasChildren' => 'bool',
            'getChildren' => '?RecursiveCachingIterator',
        ],
        'NoRewindIterator' => [
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'mixed',
            'current' => 'mixed',
            'next' => 'void',
        ],
        'AppendIterator' => [
            'append' => 'void',
            'rewind' => 'void',
            'valid' => 'bool',
            'current' => 'mixed',
            'next' => 'void',
            'getIteratorIndex' => '?int',
            'getArrayIterator' => 'ArrayIterator',
        ],
        'InfiniteIterator' => [
            'next' => 'void',
        ],
        'RegexIterator' => [
            'accept' => 'bool',
            'getMode' => 'int',
            'setMode' => 'void',
            'getFlags' => 'int',
            'setFlags' => 'void',
            'getRegex' => 'string',
            'getPregFlags' => 'int',
            'setPregFlags' => 'void',
        ],
        'RecursiveRegexIterator' => [
            'accept' => 'bool',
            'hasChildren' => 'bool',
            'getChildren' => 'RecursiveRegexIterator',
        ],
        'RecursiveTreeIterator' => [
            'key' => 'mixed',
            'current' => 'mixed',
            'getPrefix' => 'string',
            'setPostfix' => 'void',
            'setPrefixPart' => 'void',
            'getEntry' => 'string',
            'getPostfix' => 'string',
        ],
        'SplObserver' => [
            'update' => 'void',
        ],
        'SplSubject' => [
            'attach' => 'void',
            'detach' => 'void',
            'notify' => 'void',
        ],
        'SplObjectStorage' => [
            'attach' => 'void',
            'detach' => 'void',
            'contains' => 'bool',
            'addAll' => 'int',
            'removeAll' => 'int',
            'removeAllExcept' => 'int',
            'getInfo' => 'mixed',
            'setInfo' => 'void',
            'count' => 'int',
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'int',
            'current' => 'object',
            'next' => 'void',
            'unserialize' => 'void',
            'serialize' => 'string',
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
            'getHash' => 'string',
            '__serialize' => 'array',
            '__unserialize' => 'void',
            '__debugInfo' => 'array',
        ],
        'MultipleIterator' => [
            'getFlags' => 'int',
            'setFlags' => 'void',
            'attachIterator' => 'void',
            'detachIterator' => 'void',
            'containsIterator' => 'bool',
            'countIterators' => 'int',
            'rewind' => 'void',
            'valid' => 'bool',
            'key' => 'array',
            'current' => 'array',
            'next' => 'void',
            '__debugInfo' => 'array',
        ],
        'SQLite3' => [
            'open' => 'void',
            'version' => 'array',
            'lastInsertRowID' => 'int',
            'lastErrorCode' => 'int',
            'lastExtendedErrorCode' => 'int',
            'lastErrorMsg' => 'string',
            'changes' => 'int',
            'busyTimeout' => 'bool',
            'loadExtension' => 'bool',
            'backup' => 'bool',
            'escapeString' => 'string',
            'prepare' => 'SQLite3Stmt|false',
            'exec' => 'bool',
            'query' => 'SQLite3Result|false',
            'querySingle' => 'mixed',
            'createFunction' => 'bool',
            'createAggregate' => 'bool',
            'createCollation' => 'bool',
            'enableExceptions' => 'bool',
            'enableExtendedResultCodes' => 'bool',
            'setAuthorizer' => 'bool',
        ],
        'SQLite3Stmt' => [
            'bindParam' => 'bool',
            'bindValue' => 'bool',
            'clear' => 'bool',
            'close' => 'bool',
            'execute' => 'SQLite3Result|false',
            'getSQL' => 'string|false',
            'paramCount' => 'int',
            'readOnly' => 'bool',
            'reset' => 'bool',
        ],
        'SQLite3Result' => [
            'numColumns' => 'int',
            'columnName' => 'string|false',
            'columnType' => 'int|false',
            'fetchArray' => 'array|false',
            'reset' => 'bool',
        ],
        'Directory' => [
            'close' => 'void',
            'rewind' => 'void',
            'read' => 'string|false',
        ],
        'php_user_filter' => [
            'filter' => 'int',
            'onCreate' => 'bool',
            'onClose' => 'void',
        ],
        'tidy' => [
            'getOpt' => 'string|int|bool',
            'cleanRepair' => 'bool',
            'parseFile' => 'bool',
            'parseString' => 'bool',
            'repairString' => 'string|false',
            'repairFile' => 'string|false',
            'diagnose' => 'bool',
            'getRelease' => 'string',
            'getConfig' => 'array',
            'getStatus' => 'int',
            'getHtmlVer' => 'int',
            'getOptDoc' => 'string|false',
            'isXhtml' => 'bool',
            'isXml' => 'bool',
            'root' => '?tidyNode',
            'head' => '?tidyNode',
            'html' => '?tidyNode',
            'body' => '?tidyNode',
        ],
        'XMLReader' => [
            'getAttribute' => '?string',
            'getAttributeNo' => '?string',
            'getAttributeNs' => '?string',
            'getParserProperty' => 'bool',
            'isValid' => 'bool',
            'lookupNamespace' => '?string',
            'moveToAttribute' => 'bool',
            'moveToAttributeNo' => 'bool',
            'moveToAttributeNs' => 'bool',
            'moveToElement' => 'bool',
            'moveToFirstAttribute' => 'bool',
            'moveToNextAttribute' => 'bool',
            'read' => 'bool',
            'next' => 'bool',
            'readInnerXml' => 'string',
            'readOuterXml' => 'string',
            'readString' => 'string',
            'setSchema' => 'bool',
            'setParserProperty' => 'bool',
            'setRelaxNGSchema' => 'bool',
            'setRelaxNGSchemaSource' => 'bool',
            'expand' => 'DOMNode|false',
        ],
        'XMLWriter' => [
            'openUri' => 'bool',
            'openMemory' => 'bool',
            'setIndent' => 'bool',
            'setIndentString' => 'bool',
            'startComment' => 'bool',
            'endComment' => 'bool',
            'startAttribute' => 'bool',
            'endAttribute' => 'bool',
            'writeAttribute' => 'bool',
            'startAttributeNs' => 'bool',
            'writeAttributeNs' => 'bool',
            'startElement' => 'bool',
            'endElement' => 'bool',
            'fullEndElement' => 'bool',
            'startElementNs' => 'bool',
            'writeElement' => 'bool',
            'writeElementNs' => 'bool',
            'startPi' => 'bool',
            'endPi' => 'bool',
            'writePi' => 'bool',
            'startCdata' => 'bool',
            'endCdata' => 'bool',
            'writeCdata' => 'bool',
            'text' => 'bool',
            'writeRaw' => 'bool',
            'startDocument' => 'bool',
            'endDocument' => 'bool',
            'writeComment' => 'bool',
            'startDtd' => 'bool',
            'endDtd' => 'bool',
            'writeDtd' => 'bool',
            'startDtdElement' => 'bool',
            'endDtdElement' => 'bool',
            'writeDtdElement' => 'bool',
            'startDtdAttlist' => 'bool',
            'endDtdAttlist' => 'bool',
            'writeDtdAttlist' => 'bool',
            'startDtdEntity' => 'bool',
            'endDtdEntity' => 'bool',
            'writeDtdEntity' => 'bool',
            'outputMemory' => 'string',
            'flush' => 'string|int',
        ],
        'XSLTProcessor' => [
            'importStylesheet' => 'bool',
            'transformToDoc' => 'DOMDocument|false',
            'transformToUri' => 'int',
            'transformToXml' => 'string|null|false',
            'setParameter' => 'bool',
            'getParameter' => 'string|false',
            'removeParameter' => 'bool',
            'hasExsltSupport' => 'bool',
            'registerPHPFunctions' => 'void',
            'setSecurityPrefs' => 'int',
            'getSecurityPrefs' => 'int',
        ],
        'ZipArchive' => [
            'open' => 'bool|int',
            'setPassword' => 'bool',
            'close' => 'bool',
            'count' => 'int',
            'getStatusString' => 'string',
            'addEmptyDir' => 'bool',
            'addFromString' => 'bool',
            'addFile' => 'bool',
            'replaceFile' => 'bool',
            'addGlob' => 'array|false',
            'addPattern' => 'array|false',
            'renameIndex' => 'bool',
            'renameName' => 'bool',
            'setArchiveComment' => 'bool',
            'getArchiveComment' => 'string|false',
            'setCommentIndex' => 'bool',
            'setCommentName' => 'bool',
            'setMtimeIndex' => 'bool',
            'setMtimeName' => 'bool',
            'getCommentIndex' => 'string|false',
            'getCommentName' => 'string|false',
            'deleteIndex' => 'bool',
            'deleteName' => 'bool',
            'statName' => 'array|false',
            'statIndex' => 'array|false',
            'locateName' => 'int|false',
            'getNameIndex' => 'string|false',
            'unchangeArchive' => 'bool',
            'unchangeAll' => 'bool',
            'unchangeIndex' => 'bool',
            'unchangeName' => 'bool',
            'extractTo' => 'bool',
            'getFromName' => 'string|false',
            'getFromIndex' => 'string|false',
            'setExternalAttributesName' => 'bool',
            'setExternalAttributesIndex' => 'bool',
            'getExternalAttributesName' => 'bool',
            'getExternalAttributesIndex' => 'bool',
            'setCompressionName' => 'bool',
            'setCompressionIndex' => 'bool',
            'setEncryptionName' => 'bool',
            'setEncryptionIndex' => 'bool',
            'registerProgressCallback' => 'bool',
            'registerCancelCallback' => 'bool',
        ],
        'Exception' => [
            '__wakeup' => 'void',
        ],
        'Error' => [
            '__wakeup' => 'void',
        ],
        'IteratorAggregate' => [
            'getIterator' => 'Traversable',
        ],
        'Iterator' => [
            'current' => 'mixed',
            'next' => 'void',
            'key' => 'mixed',
            'valid' => 'bool',
            'rewind' => 'void',
        ],
        'ArrayAccess' => [
            'offsetExists' => 'bool',
            'offsetGet' => 'mixed',
            'offsetSet' => 'void',
            'offsetUnset' => 'void',
        ],
        'Countable' => [
            'count' => 'int',
        ],
    ];
}
���������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������������