jush.api.lowercase_keys = function (obj) {
	const result = {};
	for (const key in obj) {
		result[key.toLowerCase()] = obj[key];
	}
	return result;
};

jush.api.js = {
	'decodeURI': 'Decodes an encoded URI (string)',
	'decodeURIComponent': 'Decodes an encoded URI component (string)',
	'encodeURI': 'Encodes a string as a URI (string)',
	'encodeURIComponent': 'Encodes a string as a URI component (string)',
	'escape': 'Encodes a string (string)',
	'eval': 'Evaluates a string and executes it as if it was script code (string)',
	'isFinite': 'Checks if a value is a finite number (number)',
	'isNaN': 'Checks if a value is not a number (number)',
	'parseFloat': 'Parses a string and returns a floating point number (string)',
	'parseInt': 'Parses a string and returns an integer (string, [radix])',
	'unescape': 'Decodes a string encoded by escape() (string)',
	'Math.abs': 'Returns the absolute value of a number (x)',
	'Math.acos': 'Returns the arccosine of a number (x)',
	'Math.asin': 'Returns the arcsine of a number (x)',
	'Math.atan': 'Returns the arctangent of x as a numeric value between -PI/2 and PI/2 radians (x)',
	'Math.atan2': 'Returns the angle theta of an (x,y) point as a numeric value between -PI and PI radians (y, x)',
	'Math.ceil': 'Returns the value of a number rounded upwards to the nearest integer (x)',
	'Math.cos': 'Returns the cosine of a number (x)',
	'Math.exp': 'Returns the value of Ex (x)',
	'Math.floor': 'Returns the value of a number rounded downwards to the nearest integer (x)',
	'Math.log': 'Returns the natural logarithm (base E) of a number (x)',
	'Math.max': 'Returns the number with the highest value of x and y (x, y)',
	'Math.min': 'Returns the number with the lowest value of x and y (x, y)',
	'Math.pow': 'Returns the value of x to the power of y (x, y)',
	'Math.random': 'Returns a random number between 0 and 1 ()',
	'Math.round': 'Rounds a number to the nearest integer (x)',
	'Math.sin': 'Returns the sine of a number (x)',
	'Math.sqrt': 'Returns the square root of a number (x)',
	'Math.tan': 'Returns the tangent of an angle (x)',
	'Math.toSource': 'Represents the source code of an object ()',
	'Math.valueOf': 'Returns the primitive value of a Math object ()',
	'document.close': 'Closes an output stream opened with the document.open() method, and displays the collected data ()',
	'document.createAttribute': 'Creates an attribute node with the specified name, and returns the new Attr object (name)',
	'document.createCDATASection': 'Creates a CDATA section node (data)',
	'document.createComment': 'Creates a comment node (data)',
	'document.createDocumentFragment': 'Creates an empty DocumentFragment object, and returns it ()',
	'document.createElement': 'Creates an element node (name)',
	'document.createTextNode': 'Creates a text node (text)',
	'document.getElementById': 'Returns the element that has an ID attribute with the given value. If no such element exists, it returns null (id)',
	'document.getElementsByTagName': 'Returns a NodeList of all elements with a specified name (tagname)',
	'document.open': 'Opens a stream to collect the output from any document.write() or document.writeln() methods ([mimetype, [replace]])',
	'document.write': 'Writes HTML expressions or JavaScript code to a document (s, ...)',
	'document.writeln': 'Identical to the write() method, with the addition of writing a new line character after each expression (s, ...)',
	'location.assign': 'Loads a new document (url)',
	'location.reload': 'Reloads the current document ()',
	'location.replace': 'Replaces the current document with a new one (url)',
	'window.alert': 'Displays an alert box with a message and an OK button (message)',
	'window.blur': 'Removes focus from the current window ()',
	'window.clearInterval': 'Cancels a timeout set with setInterval() (id)',
	'window.clearTimeout': 'Cancels a timeout set with setTimeout() (id)',
	'window.close': 'Closes the current window ()',
	'window.confirm': 'Displays a dialog box with a message and an OK and a Cancel button (message)',
	'window.focus': 'Sets focus to the current window ()',
	'window.moveBy': 'Moves a window relative to its current position (x, y)',
	'window.moveTo': 'Moves a window to the specified position (x, y)',
	'window.open': 'Opens a new browser window ([url, [name, [specs, [replace]]]])',
	'window.print': 'Prints the contents of the current window ()',
	'window.prompt': 'Displays a dialog box that prompts the user for input (message, default)',
	'window.resizeBy': 'Resizes a window by the specified pixels (width, height)',
	'window.resizeTo': 'Resizes a window to the specified width and height (width, height)',
	'window.scrollBy': 'Scrolls the content by the specified number of pixels (x, y)',
	'window.scrollTo': 'Scrolls the content to the specified coordinates (x, y)',
	'window.setInterval': 'Evaluates an expression at specified intervals (fn, milisec)',
	'window.setTimeout': 'Evaluates an expression after a specified number of milliseconds (fn, milisec)'
};

jush.api.php2 = jush.api.lowercase_keys({
	'ArrayAccess::offsetExists': '(mixed $offset): bool\nWhether an offset exists',
	'ArrayAccess::offsetGet': '(mixed $offset): mixed\nOffset to retrieve',
	'ArrayAccess::offsetSet': '(mixed $offset, mixed $value): void\nAssign a value to the specified offset',
	'ArrayAccess::offsetUnset': '(mixed $offset): void\nUnset an offset',
	'BackedEnum::from': '(int|string $value): static\nMaps a scalar to an enum instance',
	'BackedEnum::tryFrom': '(int|string $value): static|null\nMaps a scalar to an enum instance or null',
	'Closure::bind': '(Closure $closure, object|null $newThis, object|string|null $newScope = "static"): Closure|null\nDuplicates a closure with a specific bound object and class scope',
	'Closure::bindTo': '(object|null $newThis, object|string|null $newScope = "static"): Closure|null\nDuplicates the closure with a new bound object and class scope',
	'Closure::call': '(object $newThis, mixed ...$args): mixed\nBinds and calls the closure',
	'Closure::fromCallable': '(callable $callback): Closure\nConverts a callable into a closure',
	'Countable::count': '(): int\nCount elements of an object',
	'Error::__clone': '(): void\nClone the error',
	'Error::getCode': '(): int\nGets the error code',
	'Error::getFile': '(): string\nGets the file in which the error occurred',
	'Error::getLine': '(): int\nGets the line in which the error occurred',
	'Error::getMessage': '(): string\nGets the error message',
	'Error::getPrevious': '(): Throwable|null\nReturns previous Throwable',
	'Error::getTrace': '(): array\nGets the stack trace',
	'Error::getTraceAsString': '(): string\nGets the stack trace as a string',
	'Error::__toString': '(): string\nString representation of the error',
	'ErrorException::getSeverity': '(): int\nGets the exception severity',
	'Exception::__clone': '(): void\nClone the exception',
	'Exception::getCode': '(): int\nGets the Exception code',
	'Exception::getFile': '(): string\nGets the file in which the exception was created',
	'Exception::getLine': '(): int\nGets the line in which the exception was created',
	'Exception::getMessage': '(): string\nGets the Exception message',
	'Exception::getPrevious': '(): Throwable|null\nReturns previous Throwable',
	'Exception::getTrace': '(): array\nGets the stack trace',
	'Exception::getTraceAsString': '(): string\nGets the stack trace as a string',
	'Exception::__toString': '(): string\nString representation of the exception',
	'Fiber::getCurrent': '(): Fiber|null\nGets the currently executing Fiber instance',
	'Fiber::getReturn': '(): mixed\nGets the value returned by the Fiber',
	'Fiber::isRunning': '(): bool\nDetermines if the fiber is running',
	'Fiber::isStarted': '(): bool\nDetermines if the fiber has started',
	'Fiber::isSuspended': '(): bool\nDetermines if the fiber is suspended',
	'Fiber::isTerminated': '(): bool\nDetermines if the fiber has terminated',
	'Fiber::resume': '(mixed $value = null): mixed\nResumes execution of the fiber with a value',
	'Fiber::start': '(mixed ...$args): mixed\nStart execution of the fiber',
	'Fiber::suspend': '(mixed $value = null): mixed\nSuspends execution of the current fiber',
	'Fiber::throw': '(Throwable $exception): mixed\nResumes execution of the fiber with an exception',
	'Generator::current': '(): mixed\nGet the yielded value',
	'Generator::getReturn': '(): mixed\nGet the return value of a generator',
	'Generator::key': '(): mixed\nGet the yielded key',
	'Generator::next': '(): void\nResume execution of the generator',
	'Generator::rewind': '(): void\nRewind the generator to the first yield',
	'Generator::send': '(mixed $value): mixed\nSend a value to the generator',
	'Generator::throw': '(Throwable $exception): mixed\nThrow an exception into the generator',
	'Generator::valid': '(): bool\nCheck if the iterator has been closed',
	'Generator::__wakeup': '(): void\nSerialize callback',
	'InternalIterator::current': '(): mixed\nReturn the current element',
	'InternalIterator::key': '(): mixed\nReturn the key of the current element',
	'InternalIterator::next': '(): void\nMove forward to next element',
	'InternalIterator::rewind': '(): void\nRewind the Iterator to the first element',
	'InternalIterator::valid': '(): bool\nCheck if current position is valid',
	'Iterator::current': '(): mixed\nReturn the current element',
	'Iterator::key': '(): mixed\nReturn the key of the current element',
	'Iterator::next': '(): void\nMove forward to next element',
	'Iterator::rewind': '(): void\nRewind the Iterator to the first element',
	'Iterator::valid': '(): bool\nChecks if current position is valid',
	'IteratorAggregate::getIterator': '(): Traversable\nRetrieve an external iterator or traversable',
	'SensitiveParameterValue::__debugInfo': '(): array\nProtects the sensitive value against accidental exposure',
	'SensitiveParameterValue::getValue': '(): mixed\nReturns the sensitive value',
	'Serializable::serialize': '(): string|null\nString representation of object',
	'Serializable::unserialize': '(string $data): void\nConstructs the object',
	'Stringable::__toString': '(): string\nGets a string representation of the object',
	'Throwable::getCode': '(): int\nGets the exception code',
	'Throwable::getFile': '(): string\nGets the file in which the object was created',
	'Throwable::getLine': '(): int\nGets the line on which the object was instantiated',
	'Throwable::getMessage': '(): string\nGets the message',
	'Throwable::getPrevious': '(): Throwable|null\nReturns the previous Throwable',
	'Throwable::getTrace': '(): array\nGets the stack trace',
	'Throwable::getTraceAsString': '(): string\nGets the stack trace as a string',
	'Throwable::__toString': '(): string\nGets a string representation of the thrown object',
	'UnitEnum::cases': '(): array\nGenerates a list of cases on an enum',
	'WeakMap::count': '(): int\nCounts the number of live entries in the map',
	'WeakMap::getIterator': '(): Iterator\nRetrieve an external iterator',
	'WeakMap::offsetExists': '(object $object): bool\nChecks whether a certain object is in the map',
	'WeakMap::offsetGet': '(object $object): mixed\nReturns the value pointed to by a certain object',
	'WeakMap::offsetSet': '(object $object, mixed $value): void\nUpdates the map with a new key-value pair',
	'WeakMap::offsetUnset': '(object $object): void\nRemoves an entry from the map',
	'WeakReference::create': '(object $object): WeakReference\nCreate a new weak reference',
	'WeakReference::get': '(): object|null\nGet a weakly referenced Object',
	'array_all': '(array $array, callable $callback): bool\nChecks if all array elements satisfy a callback function',
	'array_any': '(array $array, callable $callback): bool\nChecks if at least one array element satisfies a callback function',
	'array_change_key_case': '(array $array, int $case = CASE_LOWER): array\nChanges the case of all keys in an array',
	'array_chunk': '(array $array, int $length, bool $preserve_keys = false): array\nSplit an array into chunks',
	'array_column': '(array $array, int|string|null $column_key, int|string|null $index_key = null): array\nReturn the values from a single column in the input array',
	'array_combine': '(array $keys, array $values): array\nCreates an array by using one array for keys and another for its values',
	'array_count_values': '(array $array): array\nCounts the occurrences of each distinct value in an array',
	'array_diff_assoc': '(array $array, array ...$arrays): array\nComputes the difference of arrays with additional index check',
	'array_diff_key': '(array $array, array ...$arrays): array\nComputes the difference of arrays using keys for comparison',
	'array_diff_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays with additional index check which is performed by a user supplied callback function',
	'array_diff_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the difference of arrays using a callback function on the keys for comparison',
	'array_diff': '(array $array, array ...$arrays): array\nComputes the difference of arrays',
	'array_fill_keys': '(array $keys, mixed $value): array\nFill an array with values, specifying keys',
	'array_fill': '(int $start_index, int $count, mixed $value): array\nFill an array with values',
	'array_filter': '(array $array, callable|null $callback = null, int $mode = ?): array\nFilters elements of an array using a callback function',
	'array_find_key': '(array $array, callable $callback): mixed\nReturns the key of the first element satisfying a callback function',
	'array_find': '(array $array, callable $callback): mixed\nReturns the first element satisfying a callback function',
	'array_flip': '(array $array): array\nExchanges all keys with their associated values in an array',
	'array_intersect_assoc': '(array $array, array ...$arrays): array\nComputes the intersection of arrays with additional index check',
	'array_intersect_key': '(array $array, array ...$arrays): array\nComputes the intersection of arrays using keys for comparison',
	'array_intersect_uassoc': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares indexes by a callback function',
	'array_intersect_ukey': '(array $array, array ...$arrays, callable $key_compare_func): array\nComputes the intersection of arrays using a callback function on the keys for comparison',
	'array_intersect': '(array $array, array ...$arrays): array\nComputes the intersection of arrays',
	'array_is_list': '(array $array): bool\nChecks whether a given $array is a list',
	'array_key_exists': '(string|int|float|bool|resource|null $key, array $array): bool\nChecks if the given key or index exists in the array',
	'array_key_first': '(array $array): int|string|null\nGets the first key of an array',
	'array_key_last': '(array $array): int|string|null\nGets the last key of an array',
	'array_keys': '(array $array): array\nReturn all the keys or a subset of the keys of an array',
	'array_keys': '(array $array, mixed $filter_value, bool $strict = false): array\nReturn all the keys or a subset of the keys of an array',
	'array_map': '(callable|null $callback, array $array, array ...$arrays): array\nApplies the callback to the elements of the given arrays',
	'array_merge_recursive': '(array ...$arrays): array\nMerge one or more arrays recursively',
	'array_merge': '(array ...$arrays): array\nMerge one or more arrays',
	'array_multisort': '(array $array1, mixed $array1_sort_order = SORT_ASC, mixed $array1_sort_flags = SORT_REGULAR, mixed ...$rest): bool\nSort multiple or multi-dimensional arrays',
	'array_pad': '(array $array, int $length, mixed $value): array\nPad array to the specified length with a value',
	'array_pop': '(array $array): mixed\nPop the element off the end of array',
	'array_product': '(array $array): int|float\nCalculate the product of values in an array',
	'array_push': '(array $array, mixed ...$values): int\nPush one or more elements onto the end of array',
	'array_rand': '(array $array, int $num = 1): int|string|array\nPick one or more random keys out of an array',
	'array_reduce': '(array $array, callable $callback, mixed $initial = null): mixed\nIteratively reduce the array to a single value using a callback function',
	'array_replace_recursive': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array recursively',
	'array_replace': '(array $array, array ...$replacements): array\nReplaces elements from passed arrays into the first array',
	'array_reverse': '(array $array, bool $preserve_keys = false): array\nReturn an array with elements in reverse order',
	'array_search': '(mixed $needle, array $haystack, bool $strict = false): int|string|false\nSearches the array for a given value and returns the first corresponding key if successful',
	'array_shift': '(array $array): mixed\nShift an element off the beginning of array',
	'array_slice': '(array $array, int $offset, int|null $length = null, bool $preserve_keys = false): array\nExtract a slice of the array',
	'array_splice': '(array $array, int $offset, int|null $length = null, mixed $replacement = []): array\nRemove a portion of the array and replace it with something else',
	'array_sum': '(array $array): int|float\nCalculate the sum of values in an array',
	'array_udiff_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays with additional index check, compares data by a callback function',
	'array_udiff_uassoc': '(array $array, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the difference of arrays with additional index check, compares data and indexes by a callback function',
	'array_udiff': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the difference of arrays by using a callback function for data comparison',
	'array_uintersect_assoc': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays with additional index check, compares data by a callback function',
	'array_uintersect_uassoc': '(array $array1, array ...$arrays, callable $value_compare_func, callable $key_compare_func): array\nComputes the intersection of arrays with additional index check, compares data and indexes by separate callback functions',
	'array_uintersect': '(array $array, array ...$arrays, callable $value_compare_func): array\nComputes the intersection of arrays, compares data by a callback function',
	'array_unique': '(array $array, int $flags = SORT_STRING): array\nRemoves duplicate values from an array',
	'array_unshift': '(array $array, mixed ...$values): int\nPrepend one or more elements to the beginning of an array',
	'array_values': '(array $array): array\nReturn all the values of an array',
	'array_walk_recursive': '(array|object $array, callable $callback, mixed $arg = null): true\nApply a user function recursively to every member of an array',
	'array_walk': '(array|object $array, callable $callback, mixed $arg = null): true\nApply a user supplied function to every member of an array',
	'array': '(mixed ...$values): array\nCreate an array',
	'arsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in descending order and maintain index association',
	'asort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in ascending order and maintain index association',
	'compact': '(array|string $var_name, array|string ...$var_names): array\nCreate array containing variables and their values',
	'count': '(Countable|array $value, int $mode = COUNT_NORMAL): int\nCounts all elements in an array or in a Countable object',
	'current': '(array|object $array): mixed\nReturn the current element in an array',
	'each': '(array|object $array): array\nReturn the current key and value pair from an array and advance the array cursor',
	'end': '(array|object $array): mixed\nSet the internal pointer of an array to its last element',
	'extract': '(array $array, int $flags = EXTR_OVERWRITE, string $prefix = ""): int\nImport variables into the current symbol table from an array',
	'in_array': '(mixed $needle, array $haystack, bool $strict = false): bool\nChecks if a value exists in an array',
	'key_exists': 'Alias of array_key_exists',
	'key': '(array|object $array): int|string|null\nFetch a key from an array',
	'krsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array by key in descending order',
	'ksort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array by key in ascending order',
	'list': '(mixed $var, mixed ...$vars = ?): array\nAssign variables as if they were an array',
	'natcasesort': '(array $array): true\nSort an array using a case insensitive "natural order" algorithm',
	'natsort': '(array $array): true\nSort an array using a "natural order" algorithm',
	'next': '(array|object $array): mixed\nAdvance the internal pointer of an array',
	'pos': 'Alias of current',
	'prev': '(array|object $array): mixed\nRewind the internal array pointer',
	'range': '(string|int|float $start, string|int|float $end, int|float $step = 1): array\nCreate an array containing a range of elements',
	'reset': '(array|object $array): mixed\nSet the internal pointer of an array to its first element',
	'rsort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in descending order',
	'shuffle': '(array $array): true\nShuffle an array',
	'sizeof': 'Alias of count',
	'sort': '(array $array, int $flags = SORT_REGULAR): true\nSort an array in ascending order',
	'uasort': '(array $array, callable $callback): true\nSort an array with a user-defined comparison function and maintain index association',
	'uksort': '(array $array, callable $callback): true\nSort an array by keys using a user-defined comparison function',
	'usort': '(array $array, callable $callback): true\nSort an array by values using a user-defined comparison function',
	'class_alias': '(string $class, string $alias, bool $autoload = true): bool\nCreates an alias for a class',
	'class_exists': '(string $class, bool $autoload = true): bool\nChecks if the class has been defined',
	'enum_exists': '(string $enum, bool $autoload = true): bool\nChecks if the enum has been defined',
	'get_called_class': '(): string\nThe "Late Static Binding" class name',
	'get_class_methods': '(object|string $object_or_class): array\nGets the class methods\' names',
	'get_class_vars': '(string $class): array\nGet the default properties of the class',
	'get_class': '(object $object = ?): string\nReturns the name of the class of an object',
	'get_declared_classes': '(): array\nReturns an array with the name of the defined classes',
	'get_declared_interfaces': '(): array\nReturns an array of all declared interfaces',
	'get_declared_traits': '(): array\nReturns an array of all declared traits',
	'get_mangled_object_vars': '(object $object): array\nReturns an array of mangled object properties',
	'get_object_vars': '(object $object): array\nGets the properties of the given object',
	'get_parent_class': '(object|string $object_or_class = ?): string|false\nRetrieves the parent class name for object or class',
	'interface_exists': '(string $interface, bool $autoload = true): bool\nChecks if the interface has been defined',
	'is_a': '(mixed $object_or_class, string $class, bool $allow_string = false): bool\nChecks whether the object is of a given type or subtype',
	'is_subclass_of': '(mixed $object_or_class, string $class, bool $allow_string = true): bool\nChecks if the object has this class as one of its parents or implements it',
	'method_exists': '(object|string $object_or_class, string $method): bool\nChecks if the class method exists',
	'property_exists': '(object|string $object_or_class, string $property): bool\nChecks if the object or class has a property',
	'trait_exists': '(string $trait, bool $autoload = true): bool\nChecks if the trait exists',
	'DateInterval::createFromDateString': '(string $datetime): DateInterval\nSets up a DateInterval from the relative parts of the string',
	'date_interval_create_from_date_string': '(string $datetime): DateInterval|false\nSets up a DateInterval from the relative parts of the string',
	'DateInterval::format': '(string $format): string\nFormats the interval',
	'DatePeriod::createFromISO8601String': '(string $specification, int $options = ?): static\nCreates a new DatePeriod object from an ISO8601 string',
	'DatePeriod::getDateInterval': '(): DateInterval\nGets the interval',
	'DatePeriod::getEndDate': '(): DateTimeInterface|null\nGets the end date',
	'DatePeriod::getRecurrences': '(): int|null\nGets the number of recurrences',
	'DatePeriod::getStartDate': '(): DateTimeInterface\nGets the start date',
	'DateTime::add': '(DateInterval $interval): DateTime\nModifies a DateTime object, with added amount of days, months, years, hours, minutes and seconds',
	'date_add': '(DateTime $object, DateInterval $interval): DateTime\nModifies a DateTime object, with added amount of days, months, years, hours, minutes and seconds',
	'DateTime::createFromFormat': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTime|false\nParses a time string according to a specified format',
	'date_create_from_format': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTime|false\nParses a time string according to a specified format',
	'DateTime::createFromImmutable': '(DateTimeImmutable $object): static\nReturns new DateTime instance encapsulating the given DateTimeImmutable object',
	'DateTime::createFromInterface': '(DateTimeInterface $object): DateTime\nReturns new DateTime object encapsulating the given DateTimeInterface object',
	'DateTime::getLastErrors': 'Alias of DateTimeImmutable::getLastErrors',
	'DateTime::modify': '(string $modifier): DateTime\nAlters the timestamp',
	'date_modify': '(DateTime $object, string $modifier): DateTime|false\nAlters the timestamp',
	'DateTime::__set_state': '(array $array): DateTime\nThe __set_state handler',
	'DateTime::setDate': '(int $year, int $month, int $day): DateTime\nSets the date',
	'date_date_set': '(DateTime $object, int $year, int $month, int $day): DateTime\nSets the date',
	'DateTime::setISODate': '(int $year, int $week, int $dayOfWeek = 1): DateTime\nSets the ISO date',
	'date_isodate_set': '(DateTime $object, int $year, int $week, int $dayOfWeek = 1): DateTime\nSets the ISO date',
	'DateTime::setTime': '(int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTime\nSets the time',
	'date_time_set': '(DateTime $object, int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTime\nSets the time',
	'DateTime::setTimestamp': '(int $timestamp): DateTime\nSets the date and time based on an Unix timestamp',
	'date_timestamp_set': '(DateTime $object, int $timestamp): DateTime\nSets the date and time based on an Unix timestamp',
	'DateTime::setTimezone': '(DateTimeZone $timezone): DateTime\nSets the time zone for the DateTime object',
	'date_timezone_set': '(DateTime $object, DateTimeZone $timezone): DateTime\nSets the time zone for the DateTime object',
	'DateTime::sub': '(DateInterval $interval): DateTime\nSubtracts an amount of days, months, years, hours, minutes and seconds from a DateTime object',
	'date_sub': '(DateTime $object, DateInterval $interval): DateTime\nSubtracts an amount of days, months, years, hours, minutes and seconds from a DateTime object',
	'DateTimeImmutable::add': '(DateInterval $interval): DateTimeImmutable\nReturns a new object, with added amount of days, months, years, hours, minutes and seconds',
	'date_create_immutable': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTimeImmutable|false\nReturns new DateTimeImmutable object',
	'DateTimeImmutable::createFromFormat': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTimeImmutable|false\nParses a time string according to a specified format',
	'date_create_immutable_from_format': '(string $format, string $datetime, DateTimeZone|null $timezone = null): DateTimeImmutable|false\nParses a time string according to a specified format',
	'DateTimeImmutable::createFromInterface': '(DateTimeInterface $object): DateTimeImmutable\nReturns new DateTimeImmutable object encapsulating the given DateTimeInterface object',
	'DateTimeImmutable::createFromMutable': '(DateTime $object): static\nReturns new DateTimeImmutable instance encapsulating the given DateTime object',
	'DateTimeImmutable::getLastErrors': '(): array|false\nReturns the warnings and errors',
	'DateTimeImmutable::modify': '(string $modifier): DateTimeImmutable\nCreates a new object with modified timestamp',
	'DateTimeImmutable::__set_state': '(array $array): DateTimeImmutable\nThe __set_state handler',
	'DateTimeImmutable::setDate': '(int $year, int $month, int $day): DateTimeImmutable\nSets the date',
	'DateTimeImmutable::setISODate': '(int $year, int $week, int $dayOfWeek = 1): DateTimeImmutable\nSets the ISO date',
	'DateTimeImmutable::setTime': '(int $hour, int $minute, int $second = ?, int $microsecond = ?): DateTimeImmutable\nSets the time',
	'DateTimeImmutable::setTimestamp': '(int $timestamp): DateTimeImmutable\nSets the date and time based on a Unix timestamp',
	'DateTimeImmutable::setTimezone': '(DateTimeZone $timezone): DateTimeImmutable\nSets the time zone',
	'DateTimeImmutable::sub': '(DateInterval $interval): DateTimeImmutable\nSubtracts an amount of days, months, years, hours, minutes and seconds',
	'DateTimeInterface::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
	'DateTimeImmutable::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
	'DateTime::diff': '(DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
	'date_diff': '(DateTimeInterface $baseObject, DateTimeInterface $targetObject, bool $absolute = false): DateInterval\nReturns the difference between two DateTime objects',
	'DateTimeInterface::format': '(string $format): string\nReturns date formatted according to given format',
	'DateTimeImmutable::format': '(string $format): string\nReturns date formatted according to given format',
	'DateTime::format': '(string $format): string\nReturns date formatted according to given format',
	'date_format': '(DateTimeInterface $object, string $format): string\nReturns date formatted according to given format',
	'DateTimeInterface::getOffset': '(): int\nReturns the timezone offset',
	'DateTimeImmutable::getOffset': '(): int\nReturns the timezone offset',
	'DateTime::getOffset': '(): int\nReturns the timezone offset',
	'date_offset_get': '(DateTimeInterface $object): int\nReturns the timezone offset',
	'DateTimeInterface::getTimestamp': '(): int\nGets the Unix timestamp',
	'DateTimeImmutable::getTimestamp': '(): int\nGets the Unix timestamp',
	'DateTime::getTimestamp': '(): int\nGets the Unix timestamp',
	'date_timestamp_get': '(DateTimeInterface $object): int\nGets the Unix timestamp',
	'DateTimeInterface::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
	'DateTimeImmutable::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
	'DateTime::getTimezone': '(): DateTimeZone|false\nReturn time zone relative to given DateTime',
	'date_timezone_get': '(DateTimeInterface $object): DateTimeZone|false\nReturn time zone relative to given DateTime',
	'DateTime::__wakeup': '(): void\nThe __wakeup handler',
	'DateTimeImmutable::__wakeup': '(): void\nThe __wakeup handler',
	'DateTimeInterface::__wakeup': '(): void\nThe __wakeup handler',
	'timezone_open': '(string $timezone): DateTimeZone|false\nCreates new DateTimeZone object',
	'DateTimeZone::getLocation': '(): array|false\nReturns location information for a timezone',
	'timezone_location_get': '(DateTimeZone $object): array|false\nReturns location information for a timezone',
	'DateTimeZone::getName': '(): string\nReturns the name of the timezone',
	'timezone_name_get': '(DateTimeZone $object): string\nReturns the name of the timezone',
	'DateTimeZone::getOffset': '(DateTimeInterface $datetime): int\nReturns the timezone offset from GMT',
	'timezone_offset_get': '(DateTimeZone $object, DateTimeInterface $datetime): int\nReturns the timezone offset from GMT',
	'DateTimeZone::getTransitions': '(int $timestampBegin = PHP_INT_MIN, int $timestampEnd = PHP_INT_MAX): array|false\nReturns all transitions for the timezone',
	'timezone_transitions_get': '(DateTimeZone $object, int $timestampBegin = PHP_INT_MIN, int $timestampEnd = PHP_INT_MAX): array|false\nReturns all transitions for the timezone',
	'DateTimeZone::listAbbreviations': '(): array\nReturns associative array containing dst, offset and the timezone name',
	'timezone_abbreviations_list': '(): array\nReturns associative array containing dst, offset and the timezone name',
	'DateTimeZone::listIdentifiers': '(int $timezoneGroup = DateTimeZone::ALL, string|null $countryCode = null): array\nReturns a numerically indexed array containing all defined timezone identifiers',
	'timezone_identifiers_list': '(int $timezoneGroup = DateTimeZone::ALL, string|null $countryCode = null): array\nReturns a numerically indexed array containing all defined timezone identifiers',
	'checkdate': '(int $month, int $day, int $year): bool\nValidate a Gregorian date',
	'date_add': 'Alias of DateTime::add',
	'date_create_from_format': 'Alias of DateTime::createFromFormat',
	'date_create_immutable_from_format': 'Alias of DateTimeImmutable::createFromFormat',
	'date_create_immutable': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTimeImmutable|false\ncreate a new DateTimeImmutable object',
	'date_create': '(string $datetime = "now", DateTimeZone|null $timezone = null): DateTime|false\ncreate a new DateTime object',
	'date_date_set': 'Alias of DateTime::setDate',
	'date_default_timezone_get': '(): string\nGets the default timezone used by all date/time functions in a script',
	'date_default_timezone_set': '(string $timezoneId): bool\nSets the default timezone used by all date/time functions in a script',
	'date_diff': 'Alias of DateTime::diff',
	'date_format': 'Alias of DateTime::format',
	'date_get_last_errors': 'Alias of DateTimeImmutable::getLastErrors',
	'date_interval_create_from_date_string': 'Alias of DateInterval::createFromDateString',
	'date_interval_format': 'Alias of DateInterval::format',
	'date_isodate_set': 'Alias of DateTime::setISODate',
	'date_modify': 'Alias of DateTime::modify',
	'date_offset_get': 'Alias of DateTime::getOffset',
	'date_parse_from_format': '(string $format, string $datetime): array\nGet info about given date formatted according to the specified format',
	'date_parse': '(string $datetime): array\nReturns associative array with detailed info about given date/time',
	'date_sub': 'Alias of DateTime::sub',
	'date_sun_info': '(int $timestamp, float $latitude, float $longitude): array\nReturns an array with information about sunset/sunrise and twilight begin/end',
	'date_sunrise': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, float|null $latitude = null, float|null $longitude = null, float|null $zenith = null, float|null $utcOffset = null): string|int|float|false\nReturns time of sunrise for a given day and location',
	'date_sunset': '(int $timestamp, int $returnFormat = SUNFUNCS_RET_STRING, float|null $latitude = null, float|null $longitude = null, float|null $zenith = null, float|null $utcOffset = null): string|int|float|false\nReturns time of sunset for a given day and location',
	'date_time_set': 'Alias of DateTime::setTime',
	'date_timestamp_get': 'Alias of DateTime::getTimestamp',
	'date_timestamp_set': 'Alias of DateTime::setTimestamp',
	'date_timezone_get': 'Alias of DateTime::getTimezone',
	'date_timezone_set': 'Alias of DateTime::setTimezone',
	'date': '(string $format, int|null $timestamp = null): string\nFormat a Unix timestamp',
	'getdate': '(int|null $timestamp = null): array\nGet date/time information',
	'gettimeofday': '(bool $as_float = false): array|float\nGet current time',
	'gmdate': '(string $format, int|null $timestamp = null): string\nFormat a GMT/UTC date/time',
	'gmmktime': '(int $hour, int|null $minute = null, int|null $second = null, int|null $month = null, int|null $day = null, int|null $year = null): int|false\nGet Unix timestamp for a GMT date',
	'gmstrftime': '(string $format, int|null $timestamp = null): string|false\nFormat a GMT/UTC time/date according to locale settings',
	'idate': '(string $format, int|null $timestamp = null): int|false\nFormat a local time/date part as integer',
	'localtime': '(int|null $timestamp = null, bool $associative = false): array\nGet the local time',
	'microtime': '(bool $as_float = false): string|float\nReturn current Unix timestamp with microseconds',
	'mktime': '(int $hour, int|null $minute = null, int|null $second = null, int|null $month = null, int|null $day = null, int|null $year = null): int|false\nGet Unix timestamp for a date',
	'strftime': '(string $format, int|null $timestamp = null): string|false\nFormat a local time/date according to locale settings',
	'strptime': '(string $timestamp, string $format): array|false\nParse a time/date generated with strftime',
	'strtotime': '(string $datetime, int|null $baseTimestamp = null): int|false\nParse about any English textual datetime description into a Unix timestamp',
	'time': '(): int\nReturn current Unix timestamp',
	'timezone_abbreviations_list': 'Alias of DateTimeZone::listAbbreviations',
	'timezone_identifiers_list': 'Alias of DateTimeZone::listIdentifiers',
	'timezone_location_get': 'Alias of DateTimeZone::getLocation',
	'timezone_name_from_abbr': '(string $abbr, int $utcOffset = -1, int $isDST = -1): string|false\nReturns a timezone name by guessing from abbreviation and UTC offset',
	'timezone_name_get': 'Alias of DateTimeZone::getName',
	'timezone_offset_get': 'Alias of DateTimeZone::getOffset',
	'timezone_open': 'Alias of DateTimeZone::__construct',
	'timezone_transitions_get': 'Alias of DateTimeZone::getTransitions',
	'timezone_version_get': '(): string\nGets the version of the timezonedb',
	'Directory::close': '(): void\nClose directory handle',
	'Directory::read': '(): string|false\nRead entry from directory handle',
	'Directory::rewind': '(): void\nRewind directory handle',
	'chdir': '(string $directory): bool\nChange directory',
	'chroot': '(string $directory): bool\nChange the root directory',
	'closedir': '(resource|null $dir_handle = null): void\nClose directory handle',
	'dir': '(string $directory, resource|null $context = null): Directory|false\nReturn an instance of the Directory class',
	'getcwd': '(): string|false\nGets the current working directory',
	'opendir': '(string $directory, resource|null $context = null): resource|false\nOpen directory handle',
	'readdir': '(resource|null $dir_handle = null): string|false\nRead entry from directory handle',
	'rewinddir': '(resource|null $dir_handle = null): void\nRewind directory handle',
	'scandir': '(string $directory, int $sorting_order = SCANDIR_SORT_ASCENDING, resource|null $context = null): array|false\nList files and directories inside the specified path',
	'debug_backtrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT, int $limit = ?): array\nGenerates a backtrace',
	'debug_print_backtrace': '(int $options = ?, int $limit = ?): void\nPrints a backtrace',
	'error_clear_last': '(): void\nClear the most recent error',
	'error_get_last': '(): array|null\nGet the last occurred error',
	'error_log': '(string $message, int $message_type = ?, string|null $destination = null, string|null $additional_headers = null): bool\nSend an error message to the defined error handling routines',
	'error_reporting': '(int|null $error_level = null): int\nSets which PHP errors are reported',
	'restore_error_handler': '(): true\nRestores the previous error handler function',
	'restore_exception_handler': '(): true\nRestores the previously defined exception handler function',
	'set_error_handler': '(callable|null $callback, int $error_levels = E_ALL): callable|null\nSets a user-defined error handler function',
	'set_exception_handler': '(callable|null $callback): callable|null\nSets a user-defined exception handler function',
	'trigger_error': '(string $message, int $error_level = E_USER_NOTICE): true\nGenerates a user-level error/warning/notice message',
	'user_error': 'Alias of trigger_error',
	'escapeshellarg': '(string $arg): string\nEscape a string to be used as a shell argument',
	'escapeshellcmd': '(string $command): string\nEscape shell metacharacters',
	'exec': '(string $command, array $output = null, int $result_code = null): string|false\nExecute an external program',
	'passthru': '(string $command, int $result_code = null): false|null\nExecute an external program and display raw output',
	'proc_close': '(resource $process): int\nClose a process opened by proc_open and return the exit code of that process',
	'proc_get_status': '(resource $process): array\nGet information about a process opened by proc_open',
	'proc_nice': '(int $priority): bool\nChange the priority of the current process',
	'proc_open': '(array|string $command, array $descriptor_spec, array $pipes, string|null $cwd = null, array|null $env_vars = null, array|null $options = null): resource|false\nExecute a command and open file pointers for input/output',
	'proc_terminate': '(resource $process, int $signal = 15): bool\nKills a process opened by proc_open',
	'shell_exec': '(string $command): string|false|null\nExecute command via shell and return the complete output as a string',
	'system': '(string $command, int $result_code = null): string|false\nExecute an external program and display the output',
	'basename': '(string $path, string $suffix = ""): string\nReturns trailing name component of path',
	'chgrp': '(string $filename, string|int $group): bool\nChanges file group',
	'chmod': '(string $filename, int $permissions): bool\nChanges file mode',
	'chown': '(string $filename, string|int $user): bool\nChanges file owner',
	'clearstatcache': '(bool $clear_realpath_cache = false, string $filename = ""): void\nClears file status cache',
	'copy': '(string $from, string $to, resource|null $context = null): bool\nCopies file',
	'dirname': '(string $path, int $levels = 1): string\nReturns a parent directory\'s path',
	'disk_free_space': '(string $directory): float|false\nReturns available space on filesystem or disk partition',
	'disk_total_space': '(string $directory): float|false\nReturns the total size of a filesystem or disk partition',
	'diskfreespace': 'Alias of disk_free_space',
	'fclose': '(resource $stream): bool\nCloses an open file pointer',
	'fdatasync': '(resource $stream): bool\nSynchronizes data (but not meta-data) to the file',
	'feof': '(resource $stream): bool\nTests for end-of-file on a file pointer',
	'fflush': '(resource $stream): bool\nFlushes the output to a file',
	'fgetc': '(resource $stream): string|false\nGets character from file pointer',
	'fgetcsv': '(resource $stream, int|null $length = null, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array|false\nGets line from file pointer and parse for CSV fields',
	'fgets': '(resource $stream, int|null $length = null): string|false\nGets line from file pointer',
	'fgetss': '(resource $handle, int $length = ?, string $allowable_tags = ?): string\nGets line from file pointer and strip HTML tags',
	'file_exists': '(string $filename): bool\nChecks whether a file or directory exists',
	'file_get_contents': '(string $filename, bool $use_include_path = false, resource|null $context = null, int $offset = ?, int|null $length = null): string|false\nReads entire file into a string',
	'file_put_contents': '(string $filename, mixed $data, int $flags = ?, resource|null $context = null): int|false\nWrite data to a file',
	'file': '(string $filename, int $flags = ?, resource|null $context = null): array|false\nReads entire file into an array',
	'fileatime': '(string $filename): int|false\nGets last access time of file',
	'filectime': '(string $filename): int|false\nGets inode change time of file',
	'filegroup': '(string $filename): int|false\nGets file group',
	'fileinode': '(string $filename): int|false\nGets file inode',
	'filemtime': '(string $filename): int|false\nGets file modification time',
	'fileowner': '(string $filename): int|false\nGets file owner',
	'fileperms': '(string $filename): int|false\nGets file permissions',
	'filesize': '(string $filename): int|false\nGets file size',
	'filetype': '(string $filename): string|false\nGets file type',
	'flock': '(resource $stream, int $operation, int $would_block = null): bool\nPortable advisory file locking',
	'fnmatch': '(string $pattern, string $filename, int $flags = ?): bool\nMatch filename against a pattern',
	'fopen': '(string $filename, string $mode, bool $use_include_path = false, resource|null $context = null): resource|false\nOpens file or URL',
	'fpassthru': '(resource $stream): int\nOutput all remaining data on a file pointer',
	'fputcsv': '(resource $stream, array $fields, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\", string $eol = "\\n"): int|false\nFormat line as CSV and write to file pointer',
	'fputs': 'Alias of fwrite',
	'fread': '(resource $stream, int $length): string|false\nBinary-safe file read',
	'fscanf': '(resource $stream, string $format, mixed ...$vars): array|int|false|null\nParses input from a file according to a format',
	'fseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeeks on a file pointer',
	'fstat': '(resource $stream): array|false\nGets information about a file using an open file pointer',
	'fsync': '(resource $stream): bool\nSynchronizes changes to the file (including meta-data)',
	'ftell': '(resource $stream): int|false\nReturns the current position of the file read/write pointer',
	'ftruncate': '(resource $stream, int $size): bool\nTruncates a file to a given length',
	'fwrite': '(resource $stream, string $data, int|null $length = null): int|false\nBinary-safe file write',
	'glob': '(string $pattern, int $flags = ?): array|false\nFind pathnames matching a pattern',
	'is_dir': '(string $filename): bool\nTells whether the filename is a directory',
	'is_executable': '(string $filename): bool\nTells whether the filename is executable',
	'is_file': '(string $filename): bool\nTells whether the filename is a regular file',
	'is_link': '(string $filename): bool\nTells whether the filename is a symbolic link',
	'is_readable': '(string $filename): bool\nTells whether a file exists and is readable',
	'is_uploaded_file': '(string $filename): bool\nTells whether the file was uploaded via HTTP POST',
	'is_writable': '(string $filename): bool\nTells whether the filename is writable',
	'is_writeable': 'Alias of is_writable',
	'lchgrp': '(string $filename, string|int $group): bool\nChanges group ownership of symlink',
	'lchown': '(string $filename, string|int $user): bool\nChanges user ownership of symlink',
	'link': '(string $target, string $link): bool\nCreate a hard link',
	'linkinfo': '(string $path): int|false\nGets information about a link',
	'lstat': '(string $filename): array|false\nGives information about a file or symbolic link',
	'mkdir': '(string $directory, int $permissions = 0777, bool $recursive = false, resource|null $context = null): bool\nMakes directory',
	'move_uploaded_file': '(string $from, string $to): bool\nMoves an uploaded file to a new location',
	'parse_ini_file': '(string $filename, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration file',
	'parse_ini_string': '(string $ini_string, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false\nParse a configuration string',
	'pathinfo': '(string $path, int $flags = PATHINFO_ALL): array|string\nReturns information about a file path',
	'pclose': '(resource $handle): int\nCloses process file pointer',
	'popen': '(string $command, string $mode): resource|false\nOpens process file pointer',
	'readfile': '(string $filename, bool $use_include_path = false, resource|null $context = null): int|false\nOutputs a file',
	'readlink': '(string $path): string|false\nReturns the target of a symbolic link',
	'realpath_cache_get': '(): array\nGet realpath cache entries',
	'realpath_cache_size': '(): int\nGet realpath cache size',
	'realpath': '(string $path): string|false\nReturns canonicalized absolute pathname',
	'rename': '(string $from, string $to, resource|null $context = null): bool\nRenames a file or directory',
	'rewind': '(resource $stream): bool\nRewind the position of a file pointer',
	'rmdir': '(string $directory, resource|null $context = null): bool\nRemoves directory',
	'set_file_buffer': 'Alias of stream_set_write_buffer',
	'stat': '(string $filename): array|false\nGives information about a file',
	'symlink': '(string $target, string $link): bool\nCreates a symbolic link',
	'tempnam': '(string $directory, string $prefix): string|false\nCreate file with unique file name',
	'tmpfile': '(): resource|false\nCreates a temporary file',
	'touch': '(string $filename, int|null $mtime = null, int|null $atime = null): bool\nSets access and modification time of file',
	'umask': '(int|null $mask = null): int\nChanges the current umask',
	'unlink': '(string $filename, resource|null $context = null): bool\nDeletes a file',
	'fastcgi_finish_request': '(): bool\nFlushes all response data to the client',
	'fpm_get_status': '(): array|false\nReturns the current FPM pool status',
	'call_user_func_array': '(callable $callback, array $args): mixed\nCall a callback with an array of parameters',
	'call_user_func': '(callable $callback, mixed ...$args): mixed\nCall the callback given by the first parameter',
	'create_function': '(string $args, string $code): string\nCreate a function dynamically by evaluating a string of code',
	'forward_static_call_array': '(callable $callback, array $args): mixed\nCall a static method and pass the arguments as array',
	'forward_static_call': '(callable $callback, mixed ...$args): mixed\nCall a static method',
	'func_get_arg': '(int $position): mixed\nReturn an item from the argument list',
	'func_get_args': '(): array\nReturns an array comprising a function\'s argument list',
	'func_num_args': '(): int\nReturns the number of arguments passed to the function',
	'function_exists': '(string $function): bool\nReturn true if the given function has been defined',
	'get_defined_functions': '(bool $exclude_disabled = true): array\nReturns an array of all defined functions',
	'register_shutdown_function': '(callable $callback, mixed ...$args): void\nRegister a function for execution on shutdown',
	'register_tick_function': '(callable $callback, mixed ...$args): bool\nRegister a function for execution on each tick',
	'unregister_tick_function': '(callable $callback): void\nDe-register a function for execution on each tick',
	'hash_algos': '(): array\nReturn a list of registered hashing algorithms',
	'hash_copy': '(HashContext $context): HashContext\nCopy hashing context',
	'hash_equals': '(string $known_string, string $user_string): bool\nTiming attack safe string comparison',
	'hash_file': '(string $algo, string $filename, bool $binary = false, array $options = []): string|false\nGenerate a hash value using the contents of a given file',
	'hash_final': '(HashContext $context, bool $binary = false): string\nFinalize an incremental hash and return resulting digest',
	'hash_hkdf': '(string $algo, string $key, int $length = ?, string $info = "", string $salt = ""): string\nGenerate a HKDF key derivation of a supplied key input',
	'hash_hmac_algos': '(): array\nReturn a list of registered hashing algorithms suitable for hash_hmac',
	'hash_hmac_file': '(string $algo, string $filename, string $key, bool $binary = false): string|false\nGenerate a keyed hash value using the HMAC method and the contents of a given file',
	'hash_hmac': '(string $algo, string $data, string $key, bool $binary = false): string\nGenerate a keyed hash value using the HMAC method',
	'hash_init': '(string $algo, int $flags = ?, string $key = "", array $options = []): HashContext\nInitialize an incremental hashing context',
	'hash_pbkdf2': '(string $algo, string $password, string $salt, int $iterations, int $length = ?, bool $binary = false, array $options = []): string\nGenerate a PBKDF2 key derivation of a supplied password',
	'hash_update_file': '(HashContext $context, string $filename, resource|null $stream_context = null): bool\nPump data into an active hashing context from a file',
	'hash_update_stream': '(HashContext $context, resource $stream, int $length = -1): int\nPump data into an active hashing context from an open stream',
	'hash_update': '(HashContext $context, string $data): true\nPump data into an active hashing context',
	'hash': '(string $algo, string $data, bool $binary = false, array $options = []): string\nGenerate a hash value (message digest)',
	'HashContext::__serialize': '(): array\nSerializes the HashContext object',
	'HashContext::__unserialize': '(array $data): void\nDeserializes the $data parameter into a HashContext object',
	'assert_options': '(int $option, mixed $value = ?): mixed\nSet/get the various assert flags',
	'assert': '(mixed $assertion, Throwable|string|null $description = null): bool\nChecks an assertion',
	'cli_get_process_title': '(): string|null\nReturns the current process title',
	'cli_set_process_title': '(string $title): bool\nSets the process title',
	'dl': '(string $extension_filename): bool\nLoads a PHP extension at runtime',
	'extension_loaded': '(string $extension): bool\nFind out whether an extension is loaded',
	'gc_collect_cycles': '(): int\nForces collection of any existing garbage cycles',
	'gc_disable': '(): void\nDeactivates the circular reference collector',
	'gc_enable': '(): void\nActivates the circular reference collector',
	'gc_enabled': '(): bool\nReturns status of the circular reference collector',
	'gc_mem_caches': '(): int\nReclaims memory used by the Zend Engine memory manager',
	'gc_status': '(): array\nGets information about the garbage collector',
	'get_cfg_var': '(string $option): string|array|false\nGets the value of a PHP configuration option',
	'get_current_user': '(): string\nGets the name of the owner of the current PHP script',
	'get_defined_constants': '(bool $categorize = false): array\nReturns an associative array with the names of all the constants and their values',
	'get_extension_funcs': '(string $extension): array|false\nReturns an array with the names of the functions of a module',
	'get_include_path': '(): string|false\nGets the current include_path configuration option',
	'get_included_files': '(): array\nReturns an array with the names of included or required files',
	'get_loaded_extensions': '(bool $zend_extensions = false): array\nReturns an array with the names of all modules compiled and loaded',
	'get_magic_quotes_gpc': '(): false\nGets the current configuration setting of magic_quotes_gpc',
	'get_magic_quotes_runtime': '(): false\nGets the current active configuration setting of magic_quotes_runtime',
	'get_required_files': 'Alias of get_included_files',
	'get_resources': '(string|null $type = null): array\nReturns active resources',
	'getenv': '(string|null $name = null, bool $local_only = false): string|array|false\nGets the value of a single or all environment variables',
	'getlastmod': '(): int|false\nGets time of last page modification',
	'getmygid': '(): int|false\nGet PHP script owner\'s GID',
	'getmyinode': '(): int|false\nGets the inode of the current script',
	'getmypid': '(): int|false\nGets PHP\'s process ID',
	'getmyuid': '(): int|false\nGets PHP script owner\'s UID',
	'getopt': '(string $short_options, array $long_options = [], int $rest_index = null): array|false\nGets options from the command line argument list',
	'getrusage': '(int $mode = ?): array|false\nGets the current resource usages',
	'ini_alter': 'Alias of ini_set',
	'ini_get_all': '(string|null $extension = null, bool $details = true): array|false\nGets all configuration options',
	'ini_get': '(string $option): string|false\nGets the value of a configuration option',
	'ini_parse_quantity': '(string $shorthand): int\nGet interpreted size from ini shorthand syntax',
	'ini_restore': '(string $option): void\nRestores the value of a configuration option',
	'ini_set': '(string $option, string|int|float|bool|null $value): string|false\nSets the value of a configuration option',
	'memory_get_peak_usage': '(bool $real_usage = false): int\nReturns the peak of memory allocated by PHP',
	'memory_get_usage': '(bool $real_usage = false): int\nReturns the amount of memory allocated to PHP',
	'memory_reset_peak_usage': '(): void\nReset the peak memory usage',
	'php_ini_loaded_file': '(): string|false\nRetrieve a path to the loaded php.ini file',
	'php_ini_scanned_files': '(): string|false\nReturn a list of .ini files parsed from the additional ini dir',
	'php_sapi_name': '(): string|false\nReturns the type of interface between web server and PHP',
	'php_uname': '(string $mode = "a"): string\nReturns information about the operating system PHP is running on',
	'phpcredits': '(int $flags = CREDITS_ALL): true\nPrints out the credits for PHP',
	'phpinfo': '(int $flags = INFO_ALL): true\nOutputs information about PHP\'s configuration',
	'phpversion': '(string|null $extension = null): string|false\nGets the current PHP version',
	'putenv': '(string $assignment): bool\nSets the value of an environment variable',
	'restore_include_path': '(): void\nRestores the value of the include_path configuration option',
	'set_include_path': '(string $include_path): string|false\nSets the include_path configuration option',
	'set_time_limit': '(int $seconds): bool\nLimits the maximum execution time',
	'sys_get_temp_dir': '(): string\nReturns directory path used for temporary files',
	'version_compare': '(string $version1, string $version2, string|null $operator = null): int|bool\nCompares two "PHP-standardized" version number strings',
	'zend_thread_id': '(): int\nReturns a unique identifier for the current thread',
	'zend_version': '(): string\nGets the version of the current Zend engine',
	'json_decode': '(string $json, bool|null $associative = null, int $depth = 512, int $flags = ?): mixed\nDecodes a JSON string',
	'json_encode': '(mixed $value, int $flags = ?, int $depth = 512): string|false\nReturns the JSON representation of a value',
	'json_last_error_msg': '(): string\nReturns the error string of the last json_encode() or json_decode() call',
	'json_last_error': '(): int\nReturns the last error occurred',
	'json_validate': '(string $json, int $depth = 512, int $flags = ?): bool\nChecks if a string contains valid JSON',
	'JsonSerializable::jsonSerialize': '(): mixed\nSpecify data which should be serialized to JSON',
	'ezmlm_hash': '(string $addr): int\nCalculate the hash value needed by EZMLM',
	'mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], string $additional_params = ""): bool\nSend mail',
	'abs': '(int|float $num): int|float\nAbsolute value',
	'acos': '(float $num): float\nArc cosine',
	'acosh': '(float $num): float\nInverse hyperbolic cosine',
	'asin': '(float $num): float\nArc sine',
	'asinh': '(float $num): float\nInverse hyperbolic sine',
	'atan': '(float $num): float\nArc tangent',
	'atan2': '(float $y, float $x): float\nArc tangent of two variables',
	'atanh': '(float $num): float\nInverse hyperbolic tangent',
	'base_convert': '(string $num, int $from_base, int $to_base): string\nConvert a number between arbitrary bases',
	'bindec': '(string $binary_string): int|float\nBinary to decimal',
	'ceil': '(int|float $num): float\nRound fractions up',
	'cos': '(float $num): float\nCosine',
	'cosh': '(float $num): float\nHyperbolic cosine',
	'decbin': '(int $num): string\nDecimal to binary',
	'dechex': '(int $num): string\nDecimal to hexadecimal',
	'decoct': '(int $num): string\nDecimal to octal',
	'deg2rad': '(float $num): float\nConverts the number in degrees to the radian equivalent',
	'exp': '(float $num): float\nCalculates the exponent of e',
	'expm1': '(float $num): float\nReturns exp($num) - 1, computed in a way that is accurate even when the value of number is close to zero',
	'fdiv': '(float $num1, float $num2): float\nDivides two numbers, according to IEEE 754',
	'floor': '(int|float $num): float\nRound fractions down',
	'fmod': '(float $num1, float $num2): float\nReturns the floating point remainder (modulo) of the division of the arguments',
	'fpow': '(float $num, float $exponent): float\nRaise one number to the power of another, according to IEEE 754',
	'hexdec': '(string $hex_string): int|float\nHexadecimal to decimal',
	'hypot': '(float $x, float $y): float\nCalculate the length of the hypotenuse of a right-angle triangle',
	'intdiv': '(int $num1, int $num2): int\nInteger division',
	'is_finite': '(float $num): bool\nChecks whether a float is finite',
	'is_infinite': '(float $num): bool\nChecks whether a float is infinite',
	'is_nan': '(float $num): bool\nChecks whether a float is NAN',
	'log': '(float $num, float $base = M_E): float\nNatural logarithm',
	'log10': '(float $num): float\nBase-10 logarithm',
	'log1p': '(float $num): float\nReturns log(1 + number), computed in a way that is accurate even when the value of number is close to zero',
	'max': '(mixed $value, mixed ...$values): mixed\nFind highest value',
	'max': '(array $value_array): mixed\nFind highest value',
	'min': '(mixed $value, mixed ...$values): mixed\nFind lowest value',
	'min': '(array $value_array): mixed\nFind lowest value',
	'octdec': '(string $octal_string): int|float\nOctal to decimal',
	'pi': '(): float\nGet value of pi',
	'pow': '(mixed $num, mixed $exponent): int|float|object\nExponential expression',
	'rad2deg': '(float $num): float\nConverts the radian number to the equivalent number in degrees',
	'round': '(int|float $num, int $precision = ?, int|RoundingMode $mode = RoundingMode::HalfAwayFromZero): float\nRounds a float',
	'sin': '(float $num): float\nSine',
	'sinh': '(float $num): float\nHyperbolic sine',
	'sqrt': '(float $num): float\nSquare root',
	'tan': '(float $num): float\nTangent',
	'tanh': '(float $num): float\nHyperbolic tangent',
	'connection_aborted': '(): int\nCheck whether client disconnected',
	'connection_status': '(): int\nReturns connection status bitfield',
	'constant': '(string $name): mixed\nReturns the value of a constant',
	'define': '(string $constant_name, mixed $value, bool $case_insensitive = false): bool\nDefines a named constant',
	'defined': '(string $constant_name): bool\nChecks whether a constant with the given name exists',
	'die': 'Alias of exit',
	'eval': '(string $code): mixed\nEvaluate a string as PHP code',
	'exit': '(string|int $status = ?): never\nTerminate the current script with a status code or message',
	'get_browser': '(string|null $user_agent = null, bool $return_array = false): object|array|false\nTells what the user\'s browser is capable of',
	'highlight_file': '(string $filename, bool $return = false): string|bool\nSyntax highlighting of a file',
	'highlight_string': '(string $string, bool $return = false): string|true\nSyntax highlighting of a string',
	'hrtime': '(bool $as_number = false): array|int|float|false\nGet the system\'s high resolution time',
	'ignore_user_abort': '(bool|null $enable = null): int\nSet whether a client disconnect should abort script execution',
	'pack': '(string $format, mixed ...$values): string\nPack data into binary string',
	'php_strip_whitespace': '(string $filename): string\nReturn source with stripped comments and whitespace',
	'sapi_windows_cp_conv': '(int|string $in_codepage, int|string $out_codepage, string $subject): string|null\nConvert string from one codepage to another',
	'sapi_windows_cp_get': '(string $kind = ""): int\nGet current codepage',
	'sapi_windows_cp_is_utf8': '(): bool\nIndicates whether the codepage is UTF-8 compatible',
	'sapi_windows_cp_set': '(int $codepage): bool\nSet process codepage',
	'sapi_windows_generate_ctrl_event': '(int $event, int $pid = ?): bool\nSend a CTRL event to another process',
	'sapi_windows_set_ctrl_handler': '(callable|null $handler, bool $add = true): bool\nSet or remove a CTRL event handler',
	'sapi_windows_vt100_support': '(resource $stream, bool|null $enable = null): bool\nGet or set VT100 support for the specified stream associated to an output buffer of a Windows console.',
	'show_source': 'Alias of highlight_file',
	'sleep': '(int $seconds): int\nDelay execution',
	'sys_getloadavg': '(): array|false\nGets system load average',
	'time_nanosleep': '(int $seconds, int $nanoseconds): array|bool\nDelay for a number of seconds and nanoseconds',
	'time_sleep_until': '(float $timestamp): bool\nMake the script sleep until the specified time',
	'uniqid': '(string $prefix = "", bool $more_entropy = false): string\nGenerate a time-based identifier',
	'unpack': '(string $format, string $string, int $offset = ?): array|false\nUnpack data from binary string',
	'usleep': '(int $microseconds): void\nDelay execution in microseconds',
	'checkdnsrr': '(string $hostname, string $type = "MX"): bool\nCheck DNS records corresponding to a given Internet host name or IP address',
	'closelog': '(): true\nClose connection to system logger',
	'dns_check_record': 'Alias of checkdnsrr',
	'dns_get_mx': 'Alias of getmxrr',
	'dns_get_record': '(string $hostname, int $type = DNS_ANY, array $authoritative_name_servers = null, array $additional_records = null, bool $raw = false): array|false\nFetch DNS Resource Records associated with a hostname',
	'fsockopen': '(string $hostname, int $port = -1, int $error_code = null, string $error_message = null, float|null $timeout = null): resource|false\nOpen Internet or Unix domain socket connection',
	'gethostbyaddr': '(string $ip): string|false\nGet the Internet host name corresponding to a given IP address',
	'gethostbyname': '(string $hostname): string\nGet the IPv4 address corresponding to a given Internet host name',
	'gethostbynamel': '(string $hostname): array|false\nGet a list of IPv4 addresses corresponding to a given Internet host name',
	'gethostname': '(): string|false\nGets the host name',
	'getmxrr': '(string $hostname, array $hosts, array $weights = null): bool\nGet MX records corresponding to a given Internet host name',
	'getprotobyname': '(string $protocol): int|false\nGet protocol number associated with protocol name',
	'getprotobynumber': '(int $protocol): string|false\nGet protocol name associated with protocol number',
	'getservbyname': '(string $service, string $protocol): int|false\nGet port number associated with an Internet service and protocol',
	'getservbyport': '(int $port, string $protocol): string|false\nGet Internet service which corresponds to port and protocol',
	'header_register_callback': '(callable $callback): bool\nCall a header function',
	'header_remove': '(string|null $name = null): void\nRemove previously set headers',
	'header': '(string $header, bool $replace = true, int $response_code = ?): void\nSend a raw HTTP header',
	'headers_list': '(): array\nReturns a list of response headers sent (or ready to send)',
	'headers_sent': '(string $filename = null, int $line = null): bool\nChecks if or where headers have been sent',
	'http_clear_last_response_headers': '(): void\nClears the stored HTTP response headers',
	'http_get_last_response_headers': '(): array|null\nRetrieve last HTTP response headers',
	'http_response_code': '(int $response_code = ?): int|bool\nGet or Set the HTTP response code',
	'inet_ntop': '(string $ip): string|false\nConverts a packed internet address to a human readable representation',
	'inet_pton': '(string $ip): string|false\nConverts a human readable IP address to its packed in_addr representation',
	'ip2long': '(string $ip): int|false\nConverts a string containing an (IPv4) Internet Protocol dotted address into a long integer',
	'long2ip': '(int $ip): string\nConverts a long integer address into a string in (IPv4) Internet standard dotted format',
	'net_get_interfaces': '(): array|false\nGet network interfaces',
	'openlog': '(string $prefix, int $flags, int $facility): true\nOpen connection to system logger',
	'pfsockopen': '(string $hostname, int $port = -1, int $error_code = null, string $error_message = null, float|null $timeout = null): resource|false\nOpen persistent Internet or Unix domain socket connection',
	'request_parse_body': '(array|null $options = null): array\nRead and parse the request body and return the result',
	'setcookie': '(string $name, string $value = "", int $expires_or_options = ?, string $path = "", string $domain = "", bool $secure = false, bool $httponly = false): bool\nSend a cookie',
	'setcookie': '(string $name, string $value = "", array $options = []): bool\nSend a cookie',
	'setrawcookie': '(string $name, string $value = ?, int $expires_or_options = ?, string $path = ?, string $domain = ?, bool $secure = false, bool $httponly = false): bool\nSend a cookie without urlencoding the cookie value',
	'setrawcookie': '(string $name, string $value = ?, array $options = []): bool\nSend a cookie without urlencoding the cookie value',
	'socket_get_status': 'Alias of stream_get_meta_data',
	'socket_set_blocking': 'Alias of stream_set_blocking',
	'socket_set_timeout': 'Alias of stream_set_timeout',
	'syslog': '(int $priority, string $message): true\nGenerate a system log message',
	'opcache_compile_file': '(string $filename): bool\nCompiles and caches a PHP script without executing it',
	'opcache_get_configuration': '(): array|false\nGet configuration information about the cache',
	'opcache_get_status': '(bool $include_scripts = true): array|false\nGet status information about the cache',
	'opcache_invalidate': '(string $filename, bool $force = false): bool\nInvalidates a cached script',
	'opcache_is_script_cached': '(string $filename): bool\nTells whether a script is cached in OPCache',
	'opcache_reset': '(): bool\nResets the contents of the opcode cache',
	'flush': '(): void\nFlush system output buffer',
	'ob_clean': '(): bool\nClean (erase) the contents of the active output buffer',
	'ob_end_clean': '(): bool\nClean (erase) the contents of the active output buffer and turn it off',
	'ob_end_flush': '(): bool\nFlush (send) the return value of the active output handler and turn the active output buffer off',
	'ob_flush': '(): bool\nFlush (send) the return value of the active output handler',
	'ob_get_clean': '(): string|false\nGet the contents of the active output buffer and turn it off',
	'ob_get_contents': '(): string|false\nReturn the contents of the output buffer',
	'ob_get_flush': '(): string|false\nFlush (send) the return value of the active output handler, return the contents of the active output buffer and turn it off',
	'ob_get_length': '(): int|false\nReturn the length of the output buffer',
	'ob_get_level': '(): int\nReturn the nesting level of the output buffering mechanism',
	'ob_get_status': '(bool $full_status = false): array\nGet status of output buffers',
	'ob_implicit_flush': '(bool $enable = true): void\nTurn implicit flush on/off',
	'ob_list_handlers': '(): array\nList all output handlers in use',
	'ob_start': '(callable|null $callback = null, int $chunk_size = ?, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool\nTurn on output buffering',
	'output_add_rewrite_var': '(string $name, string $value): bool\nAdd URL rewriter values',
	'output_reset_rewrite_vars': '(): bool\nReset URL rewriter values',
	'password_algos': '(): array\nGet available password hashing algorithm IDs',
	'password_get_info': '(string $hash): array\nReturns information about the given hash',
	'password_hash': '(string $password, string|int|null $algo, array $options = []): string\nCreates a password hash',
	'password_needs_rehash': '(string $hash, string|int|null $algo, array $options = []): bool\nChecks if the given hash matches the given options',
	'password_verify': '(string $password, string $hash): bool\nVerifies that a password matches a hash',
	'preg_filter': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int $count = null): string|array|null\nPerform a regular expression search and replace',
	'preg_grep': '(string $pattern, array $array, int $flags = ?): array|false\nReturn array entries that match the pattern',
	'preg_last_error_msg': '(): string\nReturns the error message of the last PCRE regex execution',
	'preg_last_error': '(): int\nReturns the error code of the last PCRE regex execution',
	'preg_match_all': '(string $pattern, string $subject, array $matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a global regular expression match',
	'preg_match': '(string $pattern, string $subject, array $matches = null, int $flags = ?, int $offset = ?): int|false\nPerform a regular expression match',
	'preg_quote': '(string $str, string|null $delimiter = null): string\nQuote regular expression characters',
	'preg_replace_callback_array': '(array $pattern, string|array $subject, int $limit = -1, int $count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using callbacks',
	'preg_replace_callback': '(string|array $pattern, callable $callback, string|array $subject, int $limit = -1, int $count = null, int $flags = ?): string|array|null\nPerform a regular expression search and replace using a callback',
	'preg_replace': '(string|array $pattern, string|array $replacement, string|array $subject, int $limit = -1, int $count = null): string|array|null\nPerform a regular expression search and replace',
	'preg_split': '(string $pattern, string $subject, int $limit = -1, int $flags = ?): array|false\nSplit string by a regular expression',
	'getrandmax': '(): int\nShow largest possible random value',
	'lcg_value': '(): float\nCombined linear congruential generator',
	'mt_getrandmax': '(): int\nShow largest possible random value',
	'mt_rand': '(): int\nGenerate a random value via the Mersenne Twister Random Number Generator',
	'mt_rand': '(int $min, int $max): int\nGenerate a random value via the Mersenne Twister Random Number Generator',
	'mt_srand': '(int|null $seed = null, int $mode = MT_RAND_MT19937): void\nSeeds the Mersenne Twister Random Number Generator',
	'rand': '(): int\nGenerate a random integer',
	'rand': '(int $min, int $max): int\nGenerate a random integer',
	'random_bytes': '(int $length): string\nGet cryptographically secure random bytes',
	'random_int': '(int $min, int $max): int\nGet a cryptographically secure, uniformly selected integer',
	'srand': '(int|null $seed = null, int $mode = MT_RAND_MT19937): void\nSeed the random number generator',
	'Random\\Engine::generate': '(): string\nGenerates randomness',
	'Random\\Engine\\Mt19937::__debugInfo': '(): array\nReturns the internal state of the engine',
	'Random\\Engine\\Mt19937::generate': '(): string\nGenerate 32 bits of randomness',
	'Random\\Engine\\Mt19937::__serialize': '(): array\nSerializes the Mt19937 object',
	'Random\\Engine\\Mt19937::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Mt19937 object',
	'Random\\Engine\\PcgOneseq128XslRr64::__debugInfo': '(): array\nReturns the internal state of the engine',
	'Random\\Engine\\PcgOneseq128XslRr64::generate': '(): string\nGenerate 64 bits of randomness',
	'Random\\Engine\\PcgOneseq128XslRr64::jump': '(int $advance): void\nEfficiently move the engine ahead multiple steps',
	'Random\\Engine\\PcgOneseq128XslRr64::__serialize': '(): array\nSerializes the PcgOneseq128XslRr64 object',
	'Random\\Engine\\PcgOneseq128XslRr64::__unserialize': '(array $data): void\nDeserializes the $data parameter into a PcgOneseq128XslRr64 object',
	'Random\\Engine\\Secure::generate': '(): string\nGenerate cryptographically secure randomness',
	'Random\\Engine\\Xoshiro256StarStar::__debugInfo': '(): array\nReturns the internal state of the engine',
	'Random\\Engine\\Xoshiro256StarStar::generate': '(): string\nGenerate 64 bits of randomness',
	'Random\\Engine\\Xoshiro256StarStar::jump': '(): void\nEfficiently move the engine ahead by 2^128 steps',
	'Random\\Engine\\Xoshiro256StarStar::jumpLong': '(): void\nEfficiently move the engine ahead by 2^192 steps',
	'Random\\Engine\\Xoshiro256StarStar::__serialize': '(): array\nSerializes the Xoshiro256StarStar object',
	'Random\\Engine\\Xoshiro256StarStar::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Xoshiro256StarStar object',
	'Random\\Randomizer::getBytes': '(int $length): string\nGet random bytes',
	'Random\\Randomizer::getBytesFromString': '(string $string, int $length): string\nGet random bytes from a source string',
	'Random\\Randomizer::getFloat': '(float $min, float $max, Random\\IntervalBoundary $boundary = Random\\IntervalBoundary::ClosedOpen): float\nGet a uniformly selected float',
	'Random\\Randomizer::getInt': '(int $min, int $max): int\nGet a uniformly selected integer',
	'Random\\Randomizer::nextFloat': '(): float\nGet a float from the right-open interval [0.0, 1.0)',
	'Random\\Randomizer::nextInt': '(): int\nGet a positive integer',
	'Random\\Randomizer::pickArrayKeys': '(array $array, int $num): array\nSelect random array keys',
	'Random\\Randomizer::__serialize': '(): array\nSerializes the Randomizer object',
	'Random\\Randomizer::shuffleArray': '(array $array): array\nGet a permutation of an array',
	'Random\\Randomizer::shuffleBytes': '(string $bytes): string\nGet a byte-wise permutation of a string',
	'Random\\Randomizer::__unserialize': '(array $data): void\nDeserializes the $data parameter into a Randomizer object',
	'Reflection::export': '(Reflector $reflector, bool $return = false): string\nExports',
	'Reflection::getModifierNames': '(int $modifiers): array\nGets modifier names',
	'ReflectionAttribute::getArguments': '(): array\nGets arguments passed to attribute',
	'ReflectionAttribute::getName': '(): string\nGets attribute name',
	'ReflectionAttribute::getTarget': '(): int\nReturns the target of the attribute as bitmask',
	'ReflectionAttribute::isRepeated': '(): bool\nReturns whether the attribute of this name has been repeated on a code element',
	'ReflectionAttribute::newInstance': '(): object\nInstantiates the attribute class represented by this ReflectionAttribute class and arguments',
	'ReflectionClass::export': '(mixed $argument, bool $return = false): string\nExports a class',
	'ReflectionClass::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
	'ReflectionClass::getConstant': '(string $name): mixed\nGets defined constant',
	'ReflectionClass::getConstants': '(int|null $filter = null): array\nGets constants',
	'ReflectionClass::getConstructor': '(): ReflectionMethod|null\nGets the constructor of the class',
	'ReflectionClass::getDefaultProperties': '(): array\nGets default properties',
	'ReflectionClass::getDocComment': '(): string|false\nGets doc comments',
	'ReflectionClass::getEndLine': '(): int|false\nGets end line',
	'ReflectionClass::getExtension': '(): ReflectionExtension|null\nGets a ReflectionExtension object for the extension which defined the class',
	'ReflectionClass::getExtensionName': '(): string|false\nGets the name of the extension which defined the class',
	'ReflectionClass::getFileName': '(): string|false\nGets the filename of the file in which the class has been defined',
	'ReflectionClass::getInterfaceNames': '(): array\nGets the interface names',
	'ReflectionClass::getInterfaces': '(): array\nGets the interfaces',
	'ReflectionClass::getLazyInitializer': '(object $object): callable|null\nGets lazy initializer',
	'ReflectionClass::getMethod': '(string $name): ReflectionMethod\nGets a ReflectionMethod for a class method',
	'ReflectionClass::getMethods': '(int|null $filter = null): array\nGets an array of methods',
	'ReflectionClass::getModifiers': '(): int\nGets the class modifiers',
	'ReflectionClass::getName': '(): string\nGets class name',
	'ReflectionClass::getNamespaceName': '(): string\nGets namespace name',
	'ReflectionClass::getParentClass': '(): ReflectionClass|false\nGets parent class',
	'ReflectionClass::getProperties': '(int|null $filter = null): array\nGets properties',
	'ReflectionClass::getProperty': '(string $name): ReflectionProperty\nGets a ReflectionProperty for a class\'s property',
	'ReflectionClass::getReflectionConstant': '(string $name): ReflectionClassConstant|false\nGets a ReflectionClassConstant for a class\'s constant',
	'ReflectionClass::getReflectionConstants': '(int|null $filter = null): array\nGets class constants',
	'ReflectionClass::getShortName': '(): string\nGets short name',
	'ReflectionClass::getStartLine': '(): int|false\nGets starting line number',
	'ReflectionClass::getStaticProperties': '(): array\nGets static properties',
	'ReflectionClass::getStaticPropertyValue': '(string $name, mixed $def_value = ?): mixed\nGets static property value',
	'ReflectionClass::getTraitAliases': '(): array\nReturns an array of trait aliases',
	'ReflectionClass::getTraitNames': '(): array\nReturns an array of names of traits used by this class',
	'ReflectionClass::getTraits': '(): array\nReturns an array of traits used by this class',
	'ReflectionClass::hasConstant': '(string $name): bool\nChecks if constant is defined',
	'ReflectionClass::hasMethod': '(string $name): bool\nChecks if method is defined',
	'ReflectionClass::hasProperty': '(string $name): bool\nChecks if property is defined',
	'ReflectionClass::implementsInterface': '(ReflectionClass|string $interface): bool\nImplements interface',
	'ReflectionClass::initializeLazyObject': '(object $object): object\nForces initialization of a lazy object',
	'ReflectionClass::inNamespace': '(): bool\nChecks if in namespace',
	'ReflectionClass::isAbstract': '(): bool\nChecks if class is abstract',
	'ReflectionClass::isAnonymous': '(): bool\nChecks if class is anonymous',
	'ReflectionClass::isCloneable': '(): bool\nReturns whether this class is cloneable',
	'ReflectionClass::isEnum': '(): bool\nReturns whether this is an enum',
	'ReflectionClass::isFinal': '(): bool\nChecks if class is final',
	'ReflectionClass::isInstance': '(object $object): bool\nChecks class for instance',
	'ReflectionClass::isInstantiable': '(): bool\nChecks if the class is instantiable',
	'ReflectionClass::isInterface': '(): bool\nChecks if the class is an interface',
	'ReflectionClass::isInternal': '(): bool\nChecks if class is defined internally by an extension, or the core',
	'ReflectionClass::isIterable': '(): bool\nCheck whether this class is iterable',
	'ReflectionClass::isIterateable': 'Alias of ReflectionClass::isIterable',
	'ReflectionClass::isReadOnly': '(): bool\nChecks if class is readonly',
	'ReflectionClass::isSubclassOf': '(ReflectionClass|string $class): bool\nChecks if a subclass',
	'ReflectionClass::isTrait': '(): bool\nReturns whether this is a trait',
	'ReflectionClass::isUninitializedLazyObject': '(object $object): bool\nChecks if an object is lazy and uninitialized',
	'ReflectionClass::isUserDefined': '(): bool\nChecks if user defined',
	'ReflectionClass::markLazyObjectAsInitialized': '(object $object): object\nMarks a lazy object as initialized without calling the initializer or factory',
	'ReflectionClass::newInstance': '(mixed ...$args): object\nCreates a new class instance from given arguments',
	'ReflectionClass::newInstanceArgs': '(array $args = []): object|null\nCreates a new class instance from given arguments',
	'ReflectionClass::newInstanceWithoutConstructor': '(): object\nCreates a new class instance without invoking the constructor',
	'ReflectionClass::newLazyGhost': '(callable $initializer, int $options = ?): object\nCreates a new lazy ghost instance',
	'ReflectionClass::newLazyProxy': '(callable $factory, int $options = ?): object\nCreates a new lazy proxy instance',
	'ReflectionClass::resetAsLazyGhost': '(object $object, callable $initializer, int $options = ?): void\nResets an object and marks it as lazy',
	'ReflectionClass::resetAsLazyProxy': '(object $object, callable $factory, int $options = ?): void\nResets an object and marks it as lazy',
	'ReflectionClass::setStaticPropertyValue': '(string $name, mixed $value): void\nSets public static property value',
	'ReflectionClass::__toString': '(): string\nReturns the string representation of the ReflectionClass object',
	'ReflectionClassConstant::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
	'ReflectionClassConstant::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
	'ReflectionClassConstant::getDeclaringClass': '(): ReflectionClass\nGets declaring class',
	'ReflectionClassConstant::getDocComment': '(): string|false\nGets doc comments',
	'ReflectionClassConstant::getModifiers': '(): int\nGets the class constant modifiers',
	'ReflectionClassConstant::getName': '(): string\nGet name of the constant',
	'ReflectionClassConstant::getType': '(): ReflectionType|null\nGets a class constant\'s type',
	'ReflectionClassConstant::getValue': '(): mixed\nGets value',
	'ReflectionClassConstant::hasType': '(): bool\nChecks if class constant has a type',
	'ReflectionClassConstant::isDeprecated': '(): bool\nChecks if deprecated',
	'ReflectionClassConstant::isEnumCase': '(): bool\nChecks if class constant is an Enum case',
	'ReflectionClassConstant::isFinal': '(): bool\nChecks if class constant is final',
	'ReflectionClassConstant::isPrivate': '(): bool\nChecks if class constant is private',
	'ReflectionClassConstant::isProtected': '(): bool\nChecks if class constant is protected',
	'ReflectionClassConstant::isPublic': '(): bool\nChecks if class constant is public',
	'ReflectionClassConstant::__toString': '(): string\nReturns the string representation of the ReflectionClassConstant object',
	'ReflectionConstant::getExtension': '(): ReflectionExtension|null\nGets ReflectionExtension of the defining extension',
	'ReflectionConstant::getExtensionName': '(): string|false\nGets name of the defining extension',
	'ReflectionConstant::getFileName': '(): string|false\nGets name of the defining file',
	'ReflectionConstant::getName': '(): string\nGets name',
	'ReflectionConstant::getNamespaceName': '(): string\nGets namespace name',
	'ReflectionConstant::getShortName': '(): string\nGets short name',
	'ReflectionConstant::getValue': '(): mixed\nGets value',
	'ReflectionConstant::isDeprecated': '(): bool\nChecks if deprecated',
	'ReflectionConstant::__toString': '(): string\nReturns string representation',
	'ReflectionEnum::getBackingType': '(): ReflectionNamedType|null\nGets the backing type of an Enum, if any',
	'ReflectionEnum::getCase': '(string $name): ReflectionEnumUnitCase\nReturns a specific case of an Enum',
	'ReflectionEnum::getCases': '(): array\nReturns a list of all cases on an Enum',
	'ReflectionEnum::hasCase': '(string $name): bool\nChecks for a case on an Enum',
	'ReflectionEnum::isBacked': '(): bool\nDetermines if an Enum is a Backed Enum',
	'ReflectionEnumBackedCase::getBackingValue': '(): int|string\nGets the scalar value backing this Enum case',
	'ReflectionEnumUnitCase::getEnum': '(): ReflectionEnum\nGets the reflection of the enum of this case',
	'ReflectionEnumUnitCase::getValue': '(): UnitEnum\nGets the enum case object described by this reflection object',
	'ReflectionExtension::__clone': '(): void\nClones',
	'ReflectionExtension::export': '(string $name, string $return = false): string\nExport',
	'ReflectionExtension::getClasses': '(): array\nGets classes',
	'ReflectionExtension::getClassNames': '(): array\nGets class names',
	'ReflectionExtension::getConstants': '(): array\nGets constants',
	'ReflectionExtension::getDependencies': '(): array\nGets dependencies',
	'ReflectionExtension::getFunctions': '(): array\nGets extension functions',
	'ReflectionExtension::getINIEntries': '(): array\nGets extension ini entries',
	'ReflectionExtension::getName': '(): string\nGets extension name',
	'ReflectionExtension::getVersion': '(): string|null\nGets extension version',
	'ReflectionExtension::info': '(): void\nPrint extension info',
	'ReflectionExtension::isPersistent': '(): bool\nReturns whether this extension is persistent',
	'ReflectionExtension::isTemporary': '(): bool\nReturns whether this extension is temporary',
	'ReflectionExtension::__toString': '(): string\nTo string',
	'ReflectionFiber::getCallable': '(): callable\nGets the callable used to create the Fiber',
	'ReflectionFiber::getExecutingFile': '(): string|null\nGet the file name of the current execution point',
	'ReflectionFiber::getExecutingLine': '(): int|null\nGet the line number of the current execution point',
	'ReflectionFiber::getFiber': '(): Fiber\nGet the reflected Fiber instance',
	'ReflectionFiber::getTrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array\nGet the backtrace of the current execution point',
	'ReflectionFunction::export': '(string $name, string $return = ?): string\nExports function',
	'ReflectionFunction::getClosure': '(): Closure\nReturns a dynamically created closure for the function',
	'ReflectionFunction::invoke': '(mixed ...$args): mixed\nInvokes function',
	'ReflectionFunction::invokeArgs': '(array $args): mixed\nInvokes function args',
	'ReflectionFunction::isAnonymous': '(): bool\nChecks if a function is anonymous',
	'ReflectionFunction::isDisabled': '(): bool\nChecks if function is disabled',
	'ReflectionFunction::__toString': '(): string\nReturns the string representation of the ReflectionFunction object',
	'ReflectionFunctionAbstract::__clone': '(): void\nClones function',
	'ReflectionFunctionAbstract::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
	'ReflectionFunctionAbstract::getClosureCalledClass': '(): ReflectionClass|null\nReturns the class corresponding to static:: inside a closure',
	'ReflectionFunctionAbstract::getClosureScopeClass': '(): ReflectionClass|null\nReturns the class corresponding to the scope inside a closure',
	'ReflectionFunctionAbstract::getClosureThis': '(): object|null\nReturns the object which corresponds to $this inside a closure',
	'ReflectionFunctionAbstract::getClosureUsedVariables': '(): array\nReturns an array of the used variables in the Closure',
	'ReflectionFunctionAbstract::getDocComment': '(): string|false\nGets doc comment',
	'ReflectionFunctionAbstract::getEndLine': '(): int|false\nGets end line number',
	'ReflectionFunctionAbstract::getExtension': '(): ReflectionExtension|null\nGets extension info',
	'ReflectionFunctionAbstract::getExtensionName': '(): string|false\nGets extension name',
	'ReflectionFunctionAbstract::getFileName': '(): string|false\nGets file name',
	'ReflectionFunctionAbstract::getName': '(): string\nGets function name',
	'ReflectionFunctionAbstract::getNamespaceName': '(): string\nGets namespace name',
	'ReflectionFunctionAbstract::getNumberOfParameters': '(): int\nGets number of parameters',
	'ReflectionFunctionAbstract::getNumberOfRequiredParameters': '(): int\nGets number of required parameters',
	'ReflectionFunctionAbstract::getParameters': '(): array\nGets parameters',
	'ReflectionFunctionAbstract::getReturnType': '(): ReflectionType|null\nGets the specified return type of a function',
	'ReflectionFunctionAbstract::getShortName': '(): string\nGets function short name',
	'ReflectionFunctionAbstract::getStartLine': '(): int|false\nGets starting line number',
	'ReflectionFunctionAbstract::getStaticVariables': '(): array\nGets static variables',
	'ReflectionFunctionAbstract::getTentativeReturnType': '(): ReflectionType|null\nReturns the tentative return type associated with the function',
	'ReflectionFunctionAbstract::hasReturnType': '(): bool\nChecks if the function has a specified return type',
	'ReflectionFunctionAbstract::hasTentativeReturnType': '(): bool\nReturns whether the function has a tentative return type',
	'ReflectionFunctionAbstract::inNamespace': '(): bool\nChecks if function in namespace',
	'ReflectionFunctionAbstract::isClosure': '(): bool\nChecks if closure',
	'ReflectionFunctionAbstract::isDeprecated': '(): bool\nChecks if deprecated',
	'ReflectionFunctionAbstract::isGenerator': '(): bool\nReturns whether this function is a generator',
	'ReflectionFunctionAbstract::isInternal': '(): bool\nChecks if is internal',
	'ReflectionFunctionAbstract::isStatic': '(): bool\nChecks if the function is static',
	'ReflectionFunctionAbstract::isUserDefined': '(): bool\nChecks if user defined',
	'ReflectionFunctionAbstract::isVariadic': '(): bool\nChecks if the function is variadic',
	'ReflectionFunctionAbstract::returnsReference': '(): bool\nChecks if returns reference',
	'ReflectionFunctionAbstract::__toString': '(): void\nReturns the string representation of the ReflectionFunctionAbstract object',
	'ReflectionGenerator::getExecutingFile': '(): string\nGets the file name of the currently executing generator',
	'ReflectionGenerator::getExecutingGenerator': '(): Generator\nGets the executing Generator object',
	'ReflectionGenerator::getExecutingLine': '(): int\nGets the currently executing line of the generator',
	'ReflectionGenerator::getFunction': '(): ReflectionFunctionAbstract\nGets the function name of the generator',
	'ReflectionGenerator::getThis': '(): object|null\nGets the $this value of the generator',
	'ReflectionGenerator::getTrace': '(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array\nGets the trace of the executing generator',
	'ReflectionGenerator::isClosed': '(): bool\nChecks if execution finished',
	'ReflectionIntersectionType::getTypes': '(): array\nReturns the types included in the intersection type',
	'ReflectionMethod::createFromMethodName': '(string $method): static\nCreates a new ReflectionMethod',
	'ReflectionMethod::export': '(string $class, string $name, bool $return = false): string\nExport a reflection method',
	'ReflectionMethod::getClosure': '(object|null $object = null): Closure\nReturns a dynamically created closure for the method',
	'ReflectionMethod::getDeclaringClass': '(): ReflectionClass\nGets declaring class for the reflected method',
	'ReflectionMethod::getModifiers': '(): int\nGets the method modifiers',
	'ReflectionMethod::getPrototype': '(): ReflectionMethod\nGets the method prototype (if there is one)',
	'ReflectionMethod::hasPrototype': '(): bool\nReturns whether a method has a prototype',
	'ReflectionMethod::invoke': '(object|null $object, mixed ...$args): mixed\nInvoke',
	'ReflectionMethod::invokeArgs': '(object|null $object, array $args): mixed\nInvoke args',
	'ReflectionMethod::isAbstract': '(): bool\nChecks if method is abstract',
	'ReflectionMethod::isConstructor': '(): bool\nChecks if method is a constructor',
	'ReflectionMethod::isDestructor': '(): bool\nChecks if method is a destructor',
	'ReflectionMethod::isFinal': '(): bool\nChecks if method is final',
	'ReflectionMethod::isPrivate': '(): bool\nChecks if method is private',
	'ReflectionMethod::isProtected': '(): bool\nChecks if method is protected',
	'ReflectionMethod::isPublic': '(): bool\nChecks if method is public',
	'ReflectionMethod::setAccessible': '(bool $accessible): void\nSet method accessibility',
	'ReflectionMethod::__toString': '(): string\nReturns the string representation of the Reflection method object',
	'ReflectionNamedType::getName': '(): string\nGet the name of the type as a string',
	'ReflectionNamedType::isBuiltin': '(): bool\nChecks if it is a built-in type',
	'ReflectionObject::export': '(string $argument, bool $return = ?): string\nExport',
	'ReflectionParameter::allowsNull': '(): bool\nChecks if null is allowed',
	'ReflectionParameter::canBePassedByValue': '(): bool\nReturns whether this parameter can be passed by value',
	'ReflectionParameter::__clone': '(): void\nClone',
	'ReflectionParameter::export': '(string $function, string $parameter, bool $return = ?): string\nExports',
	'ReflectionParameter::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
	'ReflectionParameter::getClass': '(): ReflectionClass|null\nGet a ReflectionClass object for the parameter being reflected or null',
	'ReflectionParameter::getDeclaringClass': '(): ReflectionClass|null\nGets declaring class',
	'ReflectionParameter::getDeclaringFunction': '(): ReflectionFunctionAbstract\nGets declaring function',
	'ReflectionParameter::getDefaultValue': '(): mixed\nGets default parameter value',
	'ReflectionParameter::getDefaultValueConstantName': '(): string|null\nReturns the default value\'s constant name if default value is constant or null',
	'ReflectionParameter::getName': '(): string\nGets parameter name',
	'ReflectionParameter::getPosition': '(): int\nGets parameter position',
	'ReflectionParameter::getType': '(): ReflectionType|null\nGets a parameter\'s type',
	'ReflectionParameter::hasType': '(): bool\nChecks if parameter has a type',
	'ReflectionParameter::isArray': '(): bool\nChecks if parameter expects an array',
	'ReflectionParameter::isCallable': '(): bool\nReturns whether parameter MUST be callable',
	'ReflectionParameter::isDefaultValueAvailable': '(): bool\nChecks if a default value is available',
	'ReflectionParameter::isDefaultValueConstant': '(): bool\nReturns whether the default value of this parameter is a constant',
	'ReflectionParameter::isOptional': '(): bool\nChecks if optional',
	'ReflectionParameter::isPassedByReference': '(): bool\nChecks if passed by reference',
	'ReflectionParameter::isPromoted': '(): bool\nChecks if a parameter is promoted to a property',
	'ReflectionParameter::isVariadic': '(): bool\nChecks if the parameter is variadic',
	'ReflectionParameter::__toString': '(): string\nTo string',
	'ReflectionProperty::__clone': '(): void\nClone',
	'ReflectionProperty::export': '(mixed $class, string $name, bool $return = ?): string\nExport',
	'ReflectionProperty::getAttributes': '(string|null $name = null, int $flags = ?): array\nGets Attributes',
	'ReflectionProperty::getDeclaringClass': '(): ReflectionClass\nGets declaring class',
	'ReflectionProperty::getDefaultValue': '(): mixed\nReturns the default value declared for a property',
	'ReflectionProperty::getDocComment': '(): string|false\nGets the property doc comment',
	'ReflectionProperty::getHook': '(PropertyHookType $type): ReflectionMethod|null\nReturns a reflection object for a specified hook',
	'ReflectionProperty::getHooks': '(): array\nReturns an array of all hooks on this property',
	'ReflectionProperty::getModifiers': '(): int\nGets the property modifiers',
	'ReflectionProperty::getName': '(): string\nGets property name',
	'ReflectionProperty::getRawValue': '(object $object): mixed\nReturns the value of a property, bypassing a get hook if defined',
	'ReflectionProperty::getSettableType': '(): ReflectionType|null\nReturns the parameter type of a setter hook',
	'ReflectionProperty::getType': '(): ReflectionType|null\nGets a property\'s type',
	'ReflectionProperty::getValue': '(object|null $object = null): mixed\nGets value',
	'ReflectionProperty::hasDefaultValue': '(): bool\nChecks if property has a default value declared',
	'ReflectionProperty::hasHook': '(PropertyHookType $type): bool\nReturns whether the property has a given hook defined',
	'ReflectionProperty::hasHooks': '(): bool\nReturns whether the property has any hooks defined',
	'ReflectionProperty::hasType': '(): bool\nChecks if property has a type',
	'ReflectionProperty::isAbstract': '(): bool\nDetermines if a property is abstract',
	'ReflectionProperty::isDefault': '(): bool\nChecks if property is a default property',
	'ReflectionProperty::isDynamic': '(): bool\nChecks if property is a dynamic property',
	'ReflectionProperty::isFinal': '(): bool\nDetermines if this property is final or not',
	'ReflectionProperty::isInitialized': '(object|null $object = null): bool\nChecks whether a property is initialized',
	'ReflectionProperty::isLazy': '(object $object): bool\nChecks whether a property is lazy',
	'ReflectionProperty::isPrivate': '(): bool\nChecks if property is private',
	'ReflectionProperty::isPrivateSet': '(): bool\nChecks if property is private for writing',
	'ReflectionProperty::isPromoted': '(): bool\nChecks if property is promoted',
	'ReflectionProperty::isProtected': '(): bool\nChecks if property is protected',
	'ReflectionProperty::isProtectedSet': '(): bool\nChecks whether the property is protected for writing',
	'ReflectionProperty::isPublic': '(): bool\nChecks if property is public',
	'ReflectionProperty::isReadOnly': '(): bool\nChecks if property is readonly',
	'ReflectionProperty::isStatic': '(): bool\nChecks if property is static',
	'ReflectionProperty::isVirtual': '(): bool\nDetermines if a property is virtual',
	'ReflectionProperty::setAccessible': '(bool $accessible): void\nSet property accessibility',
	'ReflectionProperty::setRawValue': '(object $object, mixed $value): void\nSets the value of a property, bypassing a set hook if defined',
	'ReflectionProperty::setRawValueWithoutLazyInitialization': '(object $object, mixed $value): void\nSet raw property value without triggering lazy initialization',
	'ReflectionProperty::setValue': '(object|null $object, mixed $value): void\nSet property value',
	'ReflectionProperty::setValue': '(mixed $value): void\nSet property value',
	'ReflectionProperty::skipLazyInitialization': '(object $object): void\nMarks property as non-lazy',
	'ReflectionProperty::__toString': '(): string\nTo string',
	'ReflectionReference::fromArrayElement': '(array $array, int|string $key): ReflectionReference|null\nCreate a ReflectionReference from an array element',
	'ReflectionReference::getId': '(): string\nGet unique ID of a reference',
	'ReflectionType::allowsNull': '(): bool\nChecks if null is allowed',
	'ReflectionType::__toString': '(): string\nTo string',
	'ReflectionUnionType::getTypes': '(): array\nReturns the types included in the union type',
	'ReflectionZendExtension::__clone': '(): void\nClone handler',
	'ReflectionZendExtension::export': '(string $name, bool $return = ?): string\nExport',
	'ReflectionZendExtension::getAuthor': '(): string\nGets author',
	'ReflectionZendExtension::getCopyright': '(): string\nGets copyright',
	'ReflectionZendExtension::getName': '(): string\nGets name',
	'ReflectionZendExtension::getURL': '(): string\nGets URL',
	'ReflectionZendExtension::getVersion': '(): string\nGets version',
	'ReflectionZendExtension::__toString': '(): string\nTo string handler',
	'Reflector::export': '(): string\nExports',
	'AppendIterator::append': '(Iterator $iterator): void\nAppends an iterator',
	'AppendIterator::current': '(): mixed\nGets the current value',
	'AppendIterator::getArrayIterator': '(): ArrayIterator\nGets the ArrayIterator',
	'AppendIterator::getIteratorIndex': '(): int|null\nGets an index of iterators',
	'AppendIterator::key': '(): scalar\nGets the current key',
	'AppendIterator::next': '(): void\nMoves to the next element',
	'AppendIterator::rewind': '(): void\nRewinds the Iterator',
	'AppendIterator::valid': '(): bool\nChecks validity of the current element',
	'ArrayIterator::append': '(mixed $value): void\nAppend an element',
	'ArrayIterator::asort': '(int $flags = SORT_REGULAR): true\nSort entries by values',
	'ArrayIterator::count': '(): int\nCount elements',
	'ArrayIterator::current': '(): mixed\nReturn current array entry',
	'ArrayIterator::getArrayCopy': '(): array\nGet array copy',
	'ArrayIterator::getFlags': '(): int\nGet behavior flags',
	'ArrayIterator::key': '(): string|int|null\nReturn current array key',
	'ArrayIterator::ksort': '(int $flags = SORT_REGULAR): true\nSort entries by keys',
	'ArrayIterator::natcasesort': '(): true\nSort entries naturally, case insensitive',
	'ArrayIterator::natsort': '(): true\nSort entries naturally',
	'ArrayIterator::next': '(): void\nMove to next entry',
	'ArrayIterator::offsetExists': '(mixed $key): bool\nCheck if offset exists',
	'ArrayIterator::offsetGet': '(mixed $key): mixed\nGet value for an offset',
	'ArrayIterator::offsetSet': '(mixed $key, mixed $value): void\nSet value for an offset',
	'ArrayIterator::offsetUnset': '(mixed $key): void\nUnset value for an offset',
	'ArrayIterator::rewind': '(): void\nRewind array back to the start',
	'ArrayIterator::seek': '(int $offset): void\nSeeks to a position',
	'ArrayIterator::serialize': '(): string\nSerialize',
	'ArrayIterator::setFlags': '(int $flags): void\nSet behaviour flags',
	'ArrayIterator::uasort': '(callable $callback): true\nSort with a user-defined comparison function and maintain index association',
	'ArrayIterator::uksort': '(callable $callback): true\nSort by keys using a user-defined comparison function',
	'ArrayIterator::unserialize': '(string $data): void\nUnserialize',
	'ArrayIterator::valid': '(): bool\nCheck whether array contains more entries',
	'ArrayObject::append': '(mixed $value): void\nAppends the value',
	'ArrayObject::asort': '(int $flags = SORT_REGULAR): true\nSort the entries by value',
	'ArrayObject::count': '(): int\nGet the number of public properties in the ArrayObject',
	'ArrayObject::exchangeArray': '(array|object $array): array\nExchange the array for another one',
	'ArrayObject::getArrayCopy': '(): array\nCreates a copy of the ArrayObject',
	'ArrayObject::getFlags': '(): int\nGets the behavior flags',
	'ArrayObject::getIterator': '(): Iterator\nCreate a new iterator from an ArrayObject instance',
	'ArrayObject::getIteratorClass': '(): string\nGets the iterator classname for the ArrayObject',
	'ArrayObject::ksort': '(int $flags = SORT_REGULAR): true\nSort the entries by key',
	'ArrayObject::natcasesort': '(): true\nSort an array using a case insensitive "natural order" algorithm',
	'ArrayObject::natsort': '(): true\nSort entries using a "natural order" algorithm',
	'ArrayObject::offsetExists': '(mixed $key): bool\nReturns whether the requested index exists',
	'ArrayObject::offsetGet': '(mixed $key): mixed\nReturns the value at the specified index',
	'ArrayObject::offsetSet': '(mixed $key, mixed $value): void\nSets the value at the specified index to newval',
	'ArrayObject::offsetUnset': '(mixed $key): void\nUnsets the value at the specified index',
	'ArrayObject::serialize': '(): string\nSerialize an ArrayObject',
	'ArrayObject::setFlags': '(int $flags): void\nSets the behavior flags',
	'ArrayObject::setIteratorClass': '(string $iteratorClass): void\nSets the iterator classname for the ArrayObject',
	'ArrayObject::uasort': '(callable $callback): true\nSort the entries with a user-defined comparison function and maintain key association',
	'ArrayObject::uksort': '(callable $callback): true\nSort the entries by keys using a user-defined comparison function',
	'ArrayObject::unserialize': '(string $data): void\nUnserialize an ArrayObject',
	'CachingIterator::count': '(): int\nThe number of elements in the iterator',
	'CachingIterator::current': '(): mixed\nReturn the current element',
	'CachingIterator::getCache': '(): array\nRetrieve the contents of the cache',
	'CachingIterator::getFlags': '(): int\nGet flags used',
	'CachingIterator::hasNext': '(): bool\nCheck whether the inner iterator has a valid next element',
	'CachingIterator::key': '(): scalar\nReturn the key for the current element',
	'CachingIterator::next': '(): void\nMove the iterator forward',
	'CachingIterator::offsetExists': '(string $key): bool\nThe offsetExists purpose',
	'CachingIterator::offsetGet': '(string $key): mixed\nThe offsetGet purpose',
	'CachingIterator::offsetSet': '(string $key, mixed $value): void\nThe offsetSet purpose',
	'CachingIterator::offsetUnset': '(string $key): void\nThe offsetUnset purpose',
	'CachingIterator::rewind': '(): void\nRewind the iterator',
	'CachingIterator::setFlags': '(int $flags): void\nThe setFlags purpose',
	'CachingIterator::__toString': '(): string\nReturn the string representation of the current element',
	'CachingIterator::valid': '(): bool\nCheck whether the current element is valid',
	'CallbackFilterIterator::accept': '(): bool\nCalls the callback with the current value, the current key and the inner iterator as arguments',
	'DirectoryIterator::current': '(): mixed\nReturn the current DirectoryIterator item',
	'DirectoryIterator::getBasename': '(string $suffix = ""): string\nGet base name of current DirectoryIterator item',
	'DirectoryIterator::getExtension': '(): string\nGets the file extension',
	'DirectoryIterator::getFilename': '(): string\nReturn file name of current DirectoryIterator item',
	'DirectoryIterator::isDot': '(): bool\nDetermine if current DirectoryIterator item is \'.\' or \'..\'',
	'DirectoryIterator::key': '(): mixed\nReturn the key for the current DirectoryIterator item',
	'DirectoryIterator::next': '(): void\nMove forward to next DirectoryIterator item',
	'DirectoryIterator::rewind': '(): void\nRewind the DirectoryIterator back to the start',
	'DirectoryIterator::seek': '(int $offset): void\nSeek to a DirectoryIterator item',
	'DirectoryIterator::__toString': '(): string\nGet file name as a string',
	'DirectoryIterator::valid': '(): bool\nCheck whether current DirectoryIterator position is a valid file',
	'EmptyIterator::current': '(): never\nThe current() method',
	'EmptyIterator::key': '(): never\nThe key() method',
	'EmptyIterator::next': '(): void\nThe next() method',
	'EmptyIterator::rewind': '(): void\nThe rewind() method',
	'EmptyIterator::valid': '(): false\nChecks whether the current element is valid',
	'FilesystemIterator::current': '(): string|SplFileInfo|FilesystemIterator\nThe current file',
	'FilesystemIterator::getFlags': '(): int\nGet the handling flags',
	'FilesystemIterator::key': '(): string\nRetrieve the key for the current file',
	'FilesystemIterator::next': '(): void\nMove to the next file',
	'FilesystemIterator::rewind': '(): void\nRewinds back to the beginning',
	'FilesystemIterator::setFlags': '(int $flags): void\nSets handling flags',
	'FilterIterator::accept': '(): bool\nCheck whether the current element of the iterator is acceptable',
	'FilterIterator::current': '(): mixed\nGet the current element value',
	'FilterIterator::key': '(): mixed\nGet the current key',
	'FilterIterator::next': '(): void\nMove the iterator forward',
	'FilterIterator::rewind': '(): void\nRewind the iterator',
	'FilterIterator::valid': '(): bool\nCheck whether the current element is valid',
	'class_implements': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the interfaces which are implemented by the given class or interface',
	'class_parents': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the parent classes of the given class',
	'class_uses': '(object|string $object_or_class, bool $autoload = true): array|false\nReturn the traits used by the given class',
	'iterator_apply': '(Traversable $iterator, callable $callback, array|null $args = null): int\nCall a function for every element in an iterator',
	'iterator_count': '(Traversable|array $iterator): int\nCount the elements in an iterator',
	'iterator_to_array': '(Traversable|array $iterator, bool $preserve_keys = true): array\nCopy the iterator into an array',
	'spl_autoload_call': '(string $class): void\nTry all registered __autoload() functions to load the requested class',
	'spl_autoload_extensions': '(string|null $file_extensions = null): string\nRegister and return default file extensions for spl_autoload',
	'spl_autoload_functions': '(): array\nReturn all registered __autoload() functions',
	'spl_autoload_register': '(callable|null $callback = null, bool $throw = true, bool $prepend = false): bool\nRegister given function as __autoload() implementation',
	'spl_autoload_unregister': '(callable $callback): bool\nUnregister given function as __autoload() implementation',
	'spl_autoload': '(string $class, string|null $file_extensions = null): void\nDefault implementation for __autoload()',
	'spl_classes': '(): array\nReturn available SPL classes',
	'spl_object_hash': '(object $object): string\nReturn hash id for given object',
	'spl_object_id': '(object $object): int\nReturn the integer object handle for given object',
	'GlobIterator::count': '(): int\nGet the number of directories and files',
	'InfiniteIterator::next': '(): void\nMoves the inner Iterator forward or rewinds it',
	'IteratorIterator::current': '(): mixed\nGet the current value',
	'IteratorIterator::getInnerIterator': '(): Iterator|null\nGet the inner iterator',
	'IteratorIterator::key': '(): mixed\nGet the key of the current element',
	'IteratorIterator::next': '(): void\nForward to the next element',
	'IteratorIterator::rewind': '(): void\nRewind to the first element',
	'IteratorIterator::valid': '(): bool\nChecks if the current element is valid',
	'LimitIterator::current': '(): mixed\nGet current element',
	'LimitIterator::getPosition': '(): int\nReturn the current position',
	'LimitIterator::key': '(): mixed\nGet current key',
	'LimitIterator::next': '(): void\nMove the iterator forward',
	'LimitIterator::rewind': '(): void\nRewind the iterator to the specified starting offset',
	'LimitIterator::seek': '(int $offset): int\nSeek to the given position',
	'LimitIterator::valid': '(): bool\nCheck whether the current element is valid',
	'MultipleIterator::attachIterator': '(Iterator $iterator, string|int|null $info = null): void\nAttaches iterator information',
	'MultipleIterator::containsIterator': '(Iterator $iterator): bool\nChecks if an iterator is attached',
	'MultipleIterator::countIterators': '(): int\nGets the number of attached iterator instances',
	'MultipleIterator::current': '(): array\nGets the registered iterator instances',
	'MultipleIterator::detachIterator': '(Iterator $iterator): void\nDetaches an iterator',
	'MultipleIterator::getFlags': '(): int\nGets the flag information',
	'MultipleIterator::key': '(): array\nGets the registered iterator instances',
	'MultipleIterator::next': '(): void\nMoves all attached iterator instances forward',
	'MultipleIterator::rewind': '(): void\nRewinds all attached iterator instances',
	'MultipleIterator::setFlags': '(int $flags): void\nSets flags',
	'MultipleIterator::valid': '(): bool\nChecks the validity of sub iterators',
	'NoRewindIterator::current': '(): mixed\nGet the current value',
	'NoRewindIterator::key': '(): mixed\nGet the current key',
	'NoRewindIterator::next': '(): void\nForward to the next element',
	'NoRewindIterator::rewind': '(): void\nPrevents the rewind operation on the inner iterator',
	'NoRewindIterator::valid': '(): bool\nValidates the iterator',
	'OuterIterator::getInnerIterator': '(): Iterator|null\nReturns the inner iterator for the current entry',
	'ParentIterator::accept': '(): bool\nDetermines acceptability',
	'ParentIterator::getChildren': '(): ParentIterator\nReturn the inner iterator\'s children contained in a ParentIterator',
	'ParentIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
	'ParentIterator::next': '(): void\nMove the iterator forward',
	'ParentIterator::rewind': '(): void\nRewind the iterator',
	'RecursiveArrayIterator::getChildren': '(): RecursiveArrayIterator|null\nReturns an iterator for the current entry if it is an array or an object',
	'RecursiveArrayIterator::hasChildren': '(): bool\nReturns whether current entry is an array or an object',
	'RecursiveCachingIterator::getChildren': '(): RecursiveCachingIterator|null\nReturn the inner iterator\'s children as a RecursiveCachingIterator',
	'RecursiveCachingIterator::hasChildren': '(): bool\nCheck whether the current element of the inner iterator has children',
	'RecursiveCallbackFilterIterator::getChildren': '(): RecursiveCallbackFilterIterator\nReturn the inner iterator\'s children contained in a RecursiveCallbackFilterIterator',
	'RecursiveCallbackFilterIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
	'RecursiveDirectoryIterator::getChildren': '(): RecursiveDirectoryIterator\nReturns an iterator for the current entry if it is a directory',
	'RecursiveDirectoryIterator::getSubPath': '(): string\nGet sub path',
	'RecursiveDirectoryIterator::getSubPathname': '(): string\nGet sub path and name',
	'RecursiveDirectoryIterator::hasChildren': '(bool $allowLinks = false): bool\nReturns whether current entry is a directory and not \'.\' or \'..\'',
	'RecursiveDirectoryIterator::key': '(): string\nReturn path and filename of current dir entry',
	'RecursiveDirectoryIterator::next': '(): void\nMove to next entry',
	'RecursiveDirectoryIterator::rewind': '(): void\nRewind dir back to the start',
	'RecursiveFilterIterator::getChildren': '(): RecursiveFilterIterator|null\nReturn the inner iterator\'s children contained in a RecursiveFilterIterator',
	'RecursiveFilterIterator::hasChildren': '(): bool\nCheck whether the inner iterator\'s current element has children',
	'RecursiveIterator::getChildren': '(): RecursiveIterator|null\nReturns an iterator for the current entry',
	'RecursiveIterator::hasChildren': '(): bool\nReturns if an iterator can be created for the current entry',
	'RecursiveIteratorIterator::beginChildren': '(): void\nBegin children',
	'RecursiveIteratorIterator::beginIteration': '(): void\nBegin Iteration',
	'RecursiveIteratorIterator::callGetChildren': '(): RecursiveIterator|null\nGet children',
	'RecursiveIteratorIterator::callHasChildren': '(): bool\nHas children',
	'RecursiveIteratorIterator::current': '(): mixed\nAccess the current element value',
	'RecursiveIteratorIterator::endChildren': '(): void\nEnd children',
	'RecursiveIteratorIterator::endIteration': '(): void\nEnd Iteration',
	'RecursiveIteratorIterator::getDepth': '(): int\nGet the current depth of the recursive iteration',
	'RecursiveIteratorIterator::getInnerIterator': '(): RecursiveIterator\nGet inner iterator',
	'RecursiveIteratorIterator::getMaxDepth': '(): int|false\nGet max depth',
	'RecursiveIteratorIterator::getSubIterator': '(int|null $level = null): RecursiveIterator|null\nThe current active sub iterator',
	'RecursiveIteratorIterator::key': '(): mixed\nAccess the current key',
	'RecursiveIteratorIterator::next': '(): void\nMove forward to the next element',
	'RecursiveIteratorIterator::nextElement': '(): void\nNext element',
	'RecursiveIteratorIterator::rewind': '(): void\nRewind the iterator to the first element of the top level inner iterator',
	'RecursiveIteratorIterator::setMaxDepth': '(int $maxDepth = -1): void\nSet max depth',
	'RecursiveIteratorIterator::valid': '(): bool\nCheck whether the current position is valid',
	'RecursiveRegexIterator::getChildren': '(): RecursiveRegexIterator\nReturns an iterator for the current entry',
	'RecursiveRegexIterator::hasChildren': '(): bool\nReturns whether an iterator can be obtained for the current entry',
	'RecursiveTreeIterator::beginChildren': '(): void\nBegin children',
	'RecursiveTreeIterator::beginIteration': '(): RecursiveIterator\nBegin iteration',
	'RecursiveTreeIterator::callGetChildren': '(): RecursiveIterator\nGet children',
	'RecursiveTreeIterator::callHasChildren': '(): bool\nHas children',
	'RecursiveTreeIterator::current': '(): mixed\nGet current element',
	'RecursiveTreeIterator::endChildren': '(): void\nEnd children',
	'RecursiveTreeIterator::endIteration': '(): void\nEnd iteration',
	'RecursiveTreeIterator::getEntry': '(): string\nGet current entry',
	'RecursiveTreeIterator::getPostfix': '(): string\nGet the postfix',
	'RecursiveTreeIterator::getPrefix': '(): string\nGet the prefix',
	'RecursiveTreeIterator::key': '(): mixed\nGet the key of the current element',
	'RecursiveTreeIterator::next': '(): void\nMove to next element',
	'RecursiveTreeIterator::nextElement': '(): void\nNext element',
	'RecursiveTreeIterator::rewind': '(): void\nRewind iterator',
	'RecursiveTreeIterator::setPostfix': '(string $postfix): void\nSet postfix',
	'RecursiveTreeIterator::setPrefixPart': '(int $part, string $value): void\nSet a part of the prefix',
	'RecursiveTreeIterator::valid': '(): bool\nCheck validity',
	'RegexIterator::accept': '(): bool\nGet accept status',
	'RegexIterator::getFlags': '(): int\nGet flags',
	'RegexIterator::getMode': '(): int\nReturns operation mode',
	'RegexIterator::getPregFlags': '(): int\nReturns the regular expression flags',
	'RegexIterator::getRegex': '(): string\nReturns current regular expression',
	'RegexIterator::setFlags': '(int $flags): void\nSets the flags',
	'RegexIterator::setMode': '(int $mode): void\nSets the operation mode',
	'RegexIterator::setPregFlags': '(int $pregFlags): void\nSets the regular expression flags',
	'SeekableIterator::seek': '(int $offset): void\nSeeks to a position',
	'SplDoublyLinkedList::add': '(int $index, mixed $value): void\nAdd/insert a new value at the specified index',
	'SplDoublyLinkedList::bottom': '(): mixed\nPeeks at the node from the beginning of the doubly linked list',
	'SplDoublyLinkedList::count': '(): int\nCounts the number of elements in the doubly linked list',
	'SplDoublyLinkedList::current': '(): mixed\nReturn current array entry',
	'SplDoublyLinkedList::getIteratorMode': '(): int\nReturns the mode of iteration',
	'SplDoublyLinkedList::isEmpty': '(): bool\nChecks whether the doubly linked list is empty',
	'SplDoublyLinkedList::key': '(): int\nReturn current node index',
	'SplDoublyLinkedList::next': '(): void\nMove to next entry',
	'SplDoublyLinkedList::offsetExists': '(int $index): bool\nReturns whether the requested $index exists',
	'SplDoublyLinkedList::offsetGet': '(int $index): mixed\nReturns the value at the specified $index',
	'SplDoublyLinkedList::offsetSet': '(int|null $index, mixed $value): void\nSets the value at the specified $index to $value',
	'SplDoublyLinkedList::offsetUnset': '(int $index): void\nUnsets the value at the specified $index',
	'SplDoublyLinkedList::pop': '(): mixed\nPops a node from the end of the doubly linked list',
	'SplDoublyLinkedList::prev': '(): void\nMove to previous entry',
	'SplDoublyLinkedList::push': '(mixed $value): void\nPushes an element at the end of the doubly linked list',
	'SplDoublyLinkedList::rewind': '(): void\nRewind iterator back to the start',
	'SplDoublyLinkedList::serialize': '(): string\nSerializes the storage',
	'SplDoublyLinkedList::setIteratorMode': '(int $mode): int\nSets the mode of iteration',
	'SplDoublyLinkedList::shift': '(): mixed\nShifts a node from the beginning of the doubly linked list',
	'SplDoublyLinkedList::top': '(): mixed\nPeeks at the node from the end of the doubly linked list',
	'SplDoublyLinkedList::unserialize': '(string $data): void\nUnserializes the storage',
	'SplDoublyLinkedList::unshift': '(mixed $value): void\nPrepends the doubly linked list with an element',
	'SplDoublyLinkedList::valid': '(): bool\nCheck whether the doubly linked list contains more nodes',
	'SplFileInfo::getATime': '(): int|false\nGets last access time of the file',
	'SplFileInfo::getBasename': '(string $suffix = ""): string\nGets the base name of the file',
	'SplFileInfo::getCTime': '(): int|false\nGets the inode change time',
	'SplFileInfo::getExtension': '(): string\nGets the file extension',
	'SplFileInfo::getFileInfo': '(string|null $class = null): SplFileInfo\nGets an SplFileInfo object for the file',
	'SplFileInfo::getFilename': '(): string\nGets the filename',
	'SplFileInfo::getGroup': '(): int|false\nGets the file group',
	'SplFileInfo::getInode': '(): int|false\nGets the inode for the file',
	'SplFileInfo::getLinkTarget': '(): string|false\nGets the target of a link',
	'SplFileInfo::getMTime': '(): int|false\nGets the last modified time',
	'SplFileInfo::getOwner': '(): int|false\nGets the owner of the file',
	'SplFileInfo::getPath': '(): string\nGets the path without filename',
	'SplFileInfo::getPathInfo': '(string|null $class = null): SplFileInfo|null\nGets an SplFileInfo object for the path',
	'SplFileInfo::getPathname': '(): string\nGets the path to the file',
	'SplFileInfo::getPerms': '(): int|false\nGets file permissions',
	'SplFileInfo::getRealPath': '(): string|false\nGets absolute path to file',
	'SplFileInfo::getSize': '(): int|false\nGets file size',
	'SplFileInfo::getType': '(): string|false\nGets file type',
	'SplFileInfo::isDir': '(): bool\nTells if the file is a directory',
	'SplFileInfo::isExecutable': '(): bool\nTells if the file is executable',
	'SplFileInfo::isFile': '(): bool\nTells if the object references a regular file',
	'SplFileInfo::isLink': '(): bool\nTells if the file is a link',
	'SplFileInfo::isReadable': '(): bool\nTells if file is readable',
	'SplFileInfo::isWritable': '(): bool\nTells if the entry is writable',
	'SplFileInfo::openFile': '(string $mode = "r", bool $useIncludePath = false, resource|null $context = null): SplFileObject\nGets an SplFileObject object for the file',
	'SplFileInfo::setFileClass': '(string $class = SplFileObject::class): void\nSets the class used with SplFileInfo::openFile',
	'SplFileInfo::setInfoClass': '(string $class = SplFileInfo::class): void\nSets the class used with SplFileInfo::getFileInfo and SplFileInfo::getPathInfo',
	'SplFileInfo::__toString': '(): string\nReturns the path to the file as a string',
	'SplFileObject::current': '(): string|array|false\nRetrieve current line of file',
	'SplFileObject::eof': '(): bool\nReached end of file',
	'SplFileObject::fflush': '(): bool\nFlushes the output to the file',
	'SplFileObject::fgetc': '(): string|false\nGets character from file',
	'SplFileObject::fgetcsv': '(string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array|false\nGets line from file and parse as CSV fields',
	'SplFileObject::fgets': '(): string\nGets line from file',
	'SplFileObject::fgetss': '(string $allowable_tags = ?): string\nGets line from file and strip HTML tags',
	'SplFileObject::flock': '(int $operation, int $wouldBlock = null): bool\nPortable file locking',
	'SplFileObject::fpassthru': '(): int\nOutput all remaining data on a file pointer',
	'SplFileObject::fputcsv': '(array $fields, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\", string $eol = "\\n"): int|false\nWrite a field array as a CSV line',
	'SplFileObject::fread': '(int $length): string|false\nRead from file',
	'SplFileObject::fscanf': '(string $format, mixed ...$vars): array|int|null\nParses input from file according to a format',
	'SplFileObject::fseek': '(int $offset, int $whence = SEEK_SET): int\nSeek to a position',
	'SplFileObject::fstat': '(): array\nGets information about the file',
	'SplFileObject::ftell': '(): int|false\nReturn current file position',
	'SplFileObject::ftruncate': '(int $size): bool\nTruncates the file to a given length',
	'SplFileObject::fwrite': '(string $data, int $length = ?): int|false\nWrite to file',
	'SplFileObject::getChildren': '(): null\nNo purpose',
	'SplFileObject::getCsvControl': '(): array\nGet the delimiter, enclosure and escape character for CSV',
	'SplFileObject::getCurrentLine': 'Alias of SplFileObject::fgets',
	'SplFileObject::getFlags': '(): int\nGets flags for the SplFileObject',
	'SplFileObject::getMaxLineLen': '(): int\nGet maximum line length',
	'SplFileObject::hasChildren': '(): false\nSplFileObject does not have children',
	'SplFileObject::key': '(): int\nGet line number',
	'SplFileObject::next': '(): void\nRead next line',
	'SplFileObject::rewind': '(): void\nRewind the file to the first line',
	'SplFileObject::seek': '(int $line): void\nSeek to specified line',
	'SplFileObject::setCsvControl': '(string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): void\nSet the delimiter, enclosure and escape character for CSV',
	'SplFileObject::setFlags': '(int $flags): void\nSets flags for the SplFileObject',
	'SplFileObject::setMaxLineLen': '(int $maxLength): void\nSet maximum line length',
	'SplFileObject::__toString': '(): string\nReturns the current line as a string',
	'SplFileObject::valid': '(): bool\nNot at EOF',
	'SplFixedArray::count': '(): int\nReturns the size of the array',
	'SplFixedArray::current': '(): mixed\nReturn current array entry',
	'SplFixedArray::fromArray': '(array $array, bool $preserveKeys = true): SplFixedArray\nImport a PHP array in a SplFixedArray instance',
	'SplFixedArray::getIterator': '(): Iterator\nRetrieve the iterator to go through the array',
	'SplFixedArray::getSize': '(): int\nGets the size of the array',
	'SplFixedArray::jsonSerialize': '(): array\nReturns a representation that can be converted to JSON',
	'SplFixedArray::key': '(): int\nReturn current array index',
	'SplFixedArray::next': '(): void\nMove to next entry',
	'SplFixedArray::offsetExists': '(int $index): bool\nReturns whether the requested index exists',
	'SplFixedArray::offsetGet': '(int $index): mixed\nReturns the value at the specified index',
	'SplFixedArray::offsetSet': '(int $index, mixed $value): void\nSets a new value at a specified index',
	'SplFixedArray::offsetUnset': '(int $index): void\nUnsets the value at the specified $index',
	'SplFixedArray::rewind': '(): void\nRewind iterator back to the start',
	'SplFixedArray::__serialize': '(): array\nSerializes the SplFixedArray object',
	'SplFixedArray::setSize': '(int $size): true\nChange the size of an array',
	'SplFixedArray::toArray': '(): array\nReturns a PHP array from the fixed array',
	'SplFixedArray::__unserialize': '(array $data): void\nDeserializes the $data parameter into an SplFixedArray object',
	'SplFixedArray::valid': '(): bool\nCheck whether the array contains more elements',
	'SplFixedArray::__wakeup': '(): void\nReinitialises the array after being unserialised',
	'SplHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
	'SplHeap::count': '(): int\nCounts the number of elements in the heap',
	'SplHeap::current': '(): mixed\nReturn current node pointed by the iterator',
	'SplHeap::extract': '(): mixed\nExtracts a node from top of the heap and sift up',
	'SplHeap::insert': '(mixed $value): true\nInserts an element in the heap by sifting it up',
	'SplHeap::isCorrupted': '(): bool\nTells if the heap is in a corrupted state',
	'SplHeap::isEmpty': '(): bool\nChecks whether the heap is empty',
	'SplHeap::key': '(): int\nReturn current node index',
	'SplHeap::next': '(): void\nMove to the next node',
	'SplHeap::recoverFromCorruption': '(): true\nRecover from the corrupted state and allow further actions on the heap',
	'SplHeap::rewind': '(): void\nRewind iterator back to the start (no-op)',
	'SplHeap::top': '(): mixed\nPeeks at the node from the top of the heap',
	'SplHeap::valid': '(): bool\nCheck whether the heap contains more nodes',
	'SplMaxHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
	'SplMinHeap::compare': '(mixed $value1, mixed $value2): int\nCompare elements in order to place them correctly in the heap while sifting up',
	'SplObjectStorage::addAll': '(SplObjectStorage $storage): int\nAdds all objects from another storage',
	'SplObjectStorage::attach': '(object $object, mixed $info = null): void\nAdds an object in the storage',
	'SplObjectStorage::contains': '(object $object): bool\nChecks if the storage contains a specific object',
	'SplObjectStorage::count': '(int $mode = COUNT_NORMAL): int\nReturns the number of objects in the storage',
	'SplObjectStorage::current': '(): object\nReturns the current storage entry',
	'SplObjectStorage::detach': '(object $object): void\nRemoves an object from the storage',
	'SplObjectStorage::getHash': '(object $object): string\nCalculate a unique identifier for the contained objects',
	'SplObjectStorage::getInfo': '(): mixed\nReturns the data associated with the current iterator entry',
	'SplObjectStorage::key': '(): int\nReturns the index at which the iterator currently is',
	'SplObjectStorage::next': '(): void\nMove to the next entry',
	'SplObjectStorage::offsetExists': '(object $object): bool\nChecks whether an object exists in the storage',
	'SplObjectStorage::offsetGet': '(object $object): mixed\nReturns the data associated with an object',
	'SplObjectStorage::offsetSet': '(object $object, mixed $info = null): void\nAssociates data to an object in the storage',
	'SplObjectStorage::offsetUnset': '(object $object): void\nRemoves an object from the storage',
	'SplObjectStorage::removeAll': '(SplObjectStorage $storage): int\nRemoves objects contained in another storage from the current storage',
	'SplObjectStorage::removeAllExcept': '(SplObjectStorage $storage): int\nRemoves all objects except for those contained in another storage from the current storage',
	'SplObjectStorage::rewind': '(): void\nRewind the iterator to the first storage element',
	'SplObjectStorage::seek': '(int $offset): void\nSeeks iterator to a position',
	'SplObjectStorage::serialize': '(): string\nSerializes the storage',
	'SplObjectStorage::setInfo': '(mixed $info): void\nSets the data associated with the current iterator entry',
	'SplObjectStorage::unserialize': '(string $data): void\nUnserializes a storage from its string representation',
	'SplObjectStorage::valid': '(): bool\nReturns if the current iterator entry is valid',
	'SplObserver::update': '(SplSubject $subject): void\nReceive update from subject',
	'SplPriorityQueue::compare': '(mixed $priority1, mixed $priority2): int\nCompare priorities in order to place elements correctly in the heap while sifting up',
	'SplPriorityQueue::count': '(): int\nCounts the number of elements in the queue',
	'SplPriorityQueue::current': '(): mixed\nReturn current node pointed by the iterator',
	'SplPriorityQueue::extract': '(): mixed\nExtracts a node from top of the heap and sift up',
	'SplPriorityQueue::getExtractFlags': '(): int\nGet the flags of extraction',
	'SplPriorityQueue::insert': '(mixed $value, mixed $priority): true\nInserts an element in the queue by sifting it up',
	'SplPriorityQueue::isCorrupted': '(): bool\nTells if the priority queue is in a corrupted state',
	'SplPriorityQueue::isEmpty': '(): bool\nChecks whether the queue is empty',
	'SplPriorityQueue::key': '(): int\nReturn current node index',
	'SplPriorityQueue::next': '(): void\nMove to the next node',
	'SplPriorityQueue::recoverFromCorruption': '(): true\nRecover from the corrupted state and allow further actions on the queue',
	'SplPriorityQueue::rewind': '(): void\nRewind iterator back to the start (no-op)',
	'SplPriorityQueue::setExtractFlags': '(int $flags): int\nSets the mode of extraction',
	'SplPriorityQueue::top': '(): mixed\nPeeks at the node from the top of the queue',
	'SplPriorityQueue::valid': '(): bool\nCheck whether the queue contains more nodes',
	'SplQueue::dequeue': '(): mixed\nDequeues a node from the queue',
	'SplQueue::enqueue': '(mixed $value): void\nAdds an element to the queue',
	'SplSubject::attach': '(SplObserver $observer): void\nAttach an SplObserver',
	'SplSubject::detach': '(SplObserver $observer): void\nDetach an observer',
	'SplSubject::notify': '(): void\nNotify an observer',
	'stream_bucket_append': '(resource $brigade, StreamBucket $bucket): void\nAppend bucket to brigade',
	'stream_bucket_make_writeable': '(resource $brigade): StreamBucket|null\nReturns a bucket object from the brigade to operate on',
	'stream_bucket_new': '(resource $stream, string $buffer): StreamBucket\nCreate a new bucket for use on the current stream',
	'stream_bucket_prepend': '(resource $brigade, StreamBucket $bucket): void\nPrepend bucket to brigade',
	'stream_context_create': '(array|null $options = null, array|null $params = null): resource\nCreates a stream context',
	'stream_context_get_default': '(array|null $options = null): resource\nRetrieve the default stream context',
	'stream_context_get_options': '(resource $stream_or_context): array\nRetrieve options for a stream/wrapper/context',
	'stream_context_get_params': '(resource $context): array\nRetrieves parameters from a context',
	'stream_context_set_default': '(array $options): resource\nSet the default stream context',
	'stream_context_set_option': '(resource $stream_or_context, string $wrapper, string $option, mixed $value): bool\nSets an option for a stream/wrapper/context',
	'stream_context_set_options': '(resource $context, array $options): true\nSets options on the specified context',
	'stream_context_set_params': '(resource $context, array $params): true\nSet parameters for a stream/wrapper/context',
	'stream_copy_to_stream': '(resource $from, resource $to, int|null $length = null, int $offset = ?): int|false\nCopies data from one stream to another',
	'stream_filter_append': '(resource $stream, string $filtername, int $read_write = ?, mixed $params = ?): resource\nAttach a filter to a stream',
	'stream_filter_prepend': '(resource $stream, string $filtername, int $read_write = ?, mixed $params = ?): resource\nAttach a filter to a stream',
	'stream_filter_register': '(string $filter_name, string $class): bool\nRegister a user defined stream filter',
	'stream_filter_remove': '(resource $stream_filter): bool\nRemove a filter from a stream',
	'stream_get_contents': '(resource $stream, int|null $length = null, int $offset = -1): string|false\nReads remainder of a stream into a string',
	'stream_get_filters': '(): array\nRetrieve list of registered filters',
	'stream_get_line': '(resource $stream, int $length, string $ending = ""): string|false\nGets line from stream resource up to a given delimiter',
	'stream_get_meta_data': '(resource $stream): array\nRetrieves header/meta data from streams/file pointers',
	'stream_get_transports': '(): array\nRetrieve list of registered socket transports',
	'stream_get_wrappers': '(): array\nRetrieve list of registered streams',
	'stream_is_local': '(resource|string $stream): bool\nChecks if a stream is a local stream',
	'stream_isatty': '(resource $stream): bool\nCheck if a stream is a TTY',
	'': '(int $notification_code, int $severity, string|null $message, int $message_code, int $bytes_transferred, int $bytes_max): void\nA callback function for the notification context parameter',
	'stream_register_wrapper': 'Alias of stream_wrapper_register',
	'stream_resolve_include_path': '(string $filename): string|false\nResolve filename against the include path',
	'stream_select': '(array|null $read, array|null $write, array|null $except, int|null $seconds, int|null $microseconds = null): int|false\nRuns the equivalent of the select() system call on the given arrays of streams with a timeout specified by seconds and microseconds',
	'stream_set_blocking': '(resource $stream, bool $enable): bool\nSet blocking/non-blocking mode on a stream',
	'stream_set_chunk_size': '(resource $stream, int $size): int\nSet the stream chunk size',
	'stream_set_read_buffer': '(resource $stream, int $size): int\nSet read file buffering on the given stream',
	'stream_set_timeout': '(resource $stream, int $seconds, int $microseconds = ?): bool\nSet timeout period on a stream',
	'stream_set_write_buffer': '(resource $stream, int $size): int\nSets write file buffering on the given stream',
	'stream_socket_accept': '(resource $socket, float|null $timeout = null, string $peer_name = null): resource|false\nAccept a connection on a socket created by stream_socket_server',
	'stream_socket_client': '(string $address, int $error_code = null, string $error_message = null, float|null $timeout = null, int $flags = STREAM_CLIENT_CONNECT, resource|null $context = null): resource|false\nOpen Internet or Unix domain socket connection',
	'stream_socket_enable_crypto': '(resource $stream, bool $enable, int|null $crypto_method = null, resource|null $session_stream = null): int|bool\nTurns encryption on/off on an already connected socket',
	'stream_socket_get_name': '(resource $socket, bool $remote): string|false\nRetrieve the name of the local or remote sockets',
	'stream_socket_pair': '(int $domain, int $type, int $protocol): array|false\nCreates a pair of connected, indistinguishable socket streams',
	'stream_socket_recvfrom': '(resource $socket, int $length, int $flags = ?, string|null $address = null): string|false\nReceives data from a socket, connected or not',
	'stream_socket_sendto': '(resource $socket, string $data, int $flags = ?, string $address = ""): int|false\nSends a message to a socket, whether it is connected or not',
	'stream_socket_server': '(string $address, int $error_code = null, string $error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, resource|null $context = null): resource|false\nCreate an Internet or Unix domain server socket',
	'stream_socket_shutdown': '(resource $stream, int $mode): bool\nShutdown a full-duplex connection',
	'stream_supports_lock': '(resource $stream): bool\nTells whether the stream supports locking',
	'stream_wrapper_register': '(string $protocol, string $class, int $flags = ?): bool\nRegister a URL wrapper implemented as a PHP class',
	'stream_wrapper_restore': '(string $protocol): bool\nRestores a previously unregistered built-in wrapper',
	'stream_wrapper_unregister': '(string $protocol): bool\nUnregister a URL wrapper',
	'php_user_filter::filter': '(resource $in, resource $out, int $consumed, bool $closing): int\nCalled when applying the filter',
	'php_user_filter::onClose': '(): void\nCalled when closing the filter',
	'php_user_filter::onCreate': '(): bool\nCalled when creating the filter',
	'streamWrapper::dir_closedir': '(): bool\nClose directory handle',
	'streamWrapper::dir_opendir': '(string $path, int $options): bool\nOpen directory handle',
	'streamWrapper::dir_readdir': '(): string\nRead entry from directory handle',
	'streamWrapper::dir_rewinddir': '(): bool\nRewind directory handle',
	'streamWrapper::mkdir': '(string $path, int $mode, int $options): bool\nCreate a directory',
	'streamWrapper::rename': '(string $path_from, string $path_to): bool\nRenames a file or directory',
	'streamWrapper::rmdir': '(string $path, int $options): bool\nRemoves a directory',
	'streamWrapper::stream_cast': '(int $cast_as): resource\nRetrieve the underlaying resource',
	'streamWrapper::stream_close': '(): void\nClose a resource',
	'streamWrapper::stream_eof': '(): bool\nTests for end-of-file on a file pointer',
	'streamWrapper::stream_flush': '(): bool\nFlushes the output',
	'streamWrapper::stream_lock': '(int $operation): bool\nAdvisory file locking',
	'streamWrapper::stream_metadata': '(string $path, int $option, mixed $value): bool\nChange stream metadata',
	'streamWrapper::stream_open': '(string $path, string $mode, int $options, string|null $opened_path): bool\nOpens file or URL',
	'streamWrapper::stream_read': '(int $count): string|false\nRead from stream',
	'streamWrapper::stream_seek': '(int $offset, int $whence): bool\nSeeks to specific location in a stream',
	'streamWrapper::stream_set_option': '(int $option, int $arg1, int $arg2): bool\nChange stream options',
	'streamWrapper::stream_stat': '(): array|false\nRetrieve information about a file resource',
	'streamWrapper::stream_tell': '(): int\nRetrieve the current position of a stream',
	'streamWrapper::stream_truncate': '(int $new_size): bool\nTruncate stream',
	'streamWrapper::stream_write': '(string $data): int\nWrite to stream',
	'streamWrapper::unlink': '(string $path): bool\nDelete a file',
	'streamWrapper::url_stat': '(string $path, int $flags): array|false\nRetrieve information about a file',
	'addcslashes': '(string $string, string $characters): string\nQuote string with slashes in a C style',
	'addslashes': '(string $string): string\nQuote string with slashes',
	'bin2hex': '(string $string): string\nConvert binary data into hexadecimal representation',
	'chop': 'Alias of rtrim',
	'chr': '(int $codepoint): string\nGenerate a single-byte string from a number',
	'chunk_split': '(string $string, int $length = 76, string $separator = "\\r\\n"): string\nSplit a string into smaller chunks',
	'convert_cyr_string': '(string $str, string $from, string $to): string\nConvert from one Cyrillic character set to another',
	'convert_uudecode': '(string $string): string|false\nDecode a uuencoded string',
	'convert_uuencode': '(string $string): string\nUuencode a string',
	'count_chars': '(string $string, int $mode = ?): array|string\nReturn information about characters used in a string',
	'crc32': '(string $string): int\nCalculates the crc32 polynomial of a string',
	'crypt': '(string $string, string $salt): string\nOne-way string hashing',
	'echo': '(string ...$expressions): void\nOutput one or more strings',
	'explode': '(string $separator, string $string, int $limit = PHP_INT_MAX): array\nSplit a string by a string',
	'fprintf': '(resource $stream, string $format, mixed ...$values): int\nWrite a formatted string to a stream',
	'get_html_translation_table': '(int $table = HTML_SPECIALCHARS, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string $encoding = "UTF-8"): array\nReturns the translation table used by htmlspecialchars and htmlentities',
	'hebrev': '(string $string, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text',
	'hebrevc': '(string $hebrew_text, int $max_chars_per_line = ?): string\nConvert logical Hebrew text to visual text with newline conversion',
	'hex2bin': '(string $string): string|false\nDecodes a hexadecimally encoded binary string',
	'html_entity_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null): string\nConvert HTML entities to their corresponding characters',
	'htmlentities': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null, bool $double_encode = true): string\nConvert all applicable characters to HTML entities',
	'htmlspecialchars_decode': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401): string\nConvert special HTML entities back to characters',
	'htmlspecialchars': '(string $string, int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, string|null $encoding = null, bool $double_encode = true): string\nConvert special characters to HTML entities',
	'implode': '(string $separator, array $array): string\nJoin array elements with a string',
	'implode': '(array $array): string\nJoin array elements with a string',
	'implode': '(array $array, string $separator): string\nJoin array elements with a string',
	'join': 'Alias of implode',
	'lcfirst': '(string $string): string\nMake a string\'s first character lowercase',
	'levenshtein': '(string $string1, string $string2, int $insertion_cost = 1, int $replacement_cost = 1, int $deletion_cost = 1): int\nCalculate Levenshtein distance between two strings',
	'localeconv': '(): array\nGet numeric formatting information',
	'ltrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning of a string',
	'md5_file': '(string $filename, bool $binary = false): string|false\nCalculates the md5 hash of a given file',
	'md5': '(string $string, bool $binary = false): string\nCalculate the md5 hash of a string',
	'metaphone': '(string $string, int $max_phonemes = ?): string\nCalculate the metaphone key of a string',
	'money_format': '(string $format, float $number): string\nFormats a number as a currency string',
	'nl_langinfo': '(int $item): string|false\nQuery language and locale information',
	'nl2br': '(string $string, bool $use_xhtml = true): string\nInserts HTML line breaks before all newlines in a string',
	'number_format': '(float $num, int $decimals = ?, string|null $decimal_separator = ".", string|null $thousands_separator = ","): string\nFormat a number with grouped thousands',
	'ord': '(string $character): int\nConvert the first byte of a string to a value between 0 and 255',
	'parse_str': '(string $string, array $result): void\nParses the string into variables',
	'print': '(string $expression): int\nOutput a string',
	'printf': '(string $format, mixed ...$values): int\nOutput a formatted string',
	'quoted_printable_decode': '(string $string): string\nConvert a quoted-printable string to an 8 bit string',
	'quoted_printable_encode': '(string $string): string\nConvert a 8 bit string to a quoted-printable string',
	'quotemeta': '(string $string): string\nQuote meta characters',
	'rtrim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the end of a string',
	'setlocale': '(int $category, string $locales, string ...$rest): string|false\nSet locale information',
	'setlocale': '(int $category, array $locale_array): string|false\nSet locale information',
	'sha1_file': '(string $filename, bool $binary = false): string|false\nCalculate the sha1 hash of a file',
	'sha1': '(string $string, bool $binary = false): string\nCalculate the sha1 hash of a string',
	'similar_text': '(string $string1, string $string2, float $percent = null): int\nCalculate the similarity between two strings',
	'soundex': '(string $string): string\nCalculate the soundex key of a string',
	'sprintf': '(string $format, mixed ...$values): string\nReturn a formatted string',
	'sscanf': '(string $string, string $format, mixed ...$vars): array|int|null\nParses input from a string according to a format',
	'str_contains': '(string $haystack, string $needle): bool\nDetermine if a string contains a given substring',
	'str_decrement': '(string $string): string\nDecrement an alphanumeric string',
	'str_ends_with': '(string $haystack, string $needle): bool\nChecks if a string ends with a given substring',
	'str_getcsv': '(string $string, string $separator = ",", string $enclosure = "\\"", string $escape = "\\\\"): array\nParse a CSV string into an array',
	'str_increment': '(string $string): string\nIncrement an alphanumeric string',
	'str_ireplace': '(array|string $search, array|string $replace, string|array $subject, int $count = null): string|array\nCase-insensitive version of str_replace',
	'str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT): string\nPad a string to a certain length with another string',
	'str_repeat': '(string $string, int $times): string\nRepeat a string',
	'str_replace': '(array|string $search, array|string $replace, string|array $subject, int $count = null): string|array\nReplace all occurrences of the search string with the replacement string',
	'str_rot13': '(string $string): string\nPerform the rot13 transform on a string',
	'str_shuffle': '(string $string): string\nRandomly shuffles a string',
	'str_split': '(string $string, int $length = 1): array\nConvert a string to an array',
	'str_starts_with': '(string $haystack, string $needle): bool\nChecks if a string starts with a given substring',
	'str_word_count': '(string $string, int $format = ?, string|null $characters = null): array|int\nReturn information about words used in a string',
	'strcasecmp': '(string $string1, string $string2): int\nBinary safe case-insensitive string comparison',
	'strchr': 'Alias of strstr',
	'strcmp': '(string $string1, string $string2): int\nBinary safe string comparison',
	'strcoll': '(string $string1, string $string2): int\nLocale based string comparison',
	'strcspn': '(string $string, string $characters, int $offset = ?, int|null $length = null): int\nFind length of initial segment not matching mask',
	'strip_tags': '(string $string, array|string|null $allowed_tags = null): string\nStrip HTML and PHP tags from a string',
	'stripcslashes': '(string $string): string\nUn-quote string quoted with addcslashes',
	'stripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a case-insensitive substring in a string',
	'stripslashes': '(string $string): string\nUn-quotes a quoted string',
	'stristr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nCase-insensitive strstr',
	'strlen': '(string $string): int\nGet string length',
	'strnatcasecmp': '(string $string1, string $string2): int\nCase insensitive string comparisons using a "natural order" algorithm',
	'strnatcmp': '(string $string1, string $string2): int\nString comparisons using a "natural order" algorithm',
	'strncasecmp': '(string $string1, string $string2, int $length): int\nBinary safe case-insensitive string comparison of the first n characters',
	'strncmp': '(string $string1, string $string2, int $length): int\nBinary safe string comparison of the first n characters',
	'strpbrk': '(string $string, string $characters): string|false\nSearch a string for any of a set of characters',
	'strpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the first occurrence of a substring in a string',
	'strrchr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the last occurrence of a character in a string',
	'strrev': '(string $string): string\nReverse a string',
	'strripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a case-insensitive substring in a string',
	'strrpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind the position of the last occurrence of a substring in a string',
	'strspn': '(string $string, string $characters, int $offset = ?, int|null $length = null): int\nFinds the length of the initial segment of a string consisting entirely of characters contained within a given mask',
	'strstr': '(string $haystack, string $needle, bool $before_needle = false): string|false\nFind the first occurrence of a string',
	'strtok': '(string $string, string $token): string|false\nTokenize string',
	'strtok': '(string $token): string|false\nTokenize string',
	'strtolower': '(string $string): string\nMake a string lowercase',
	'strtoupper': '(string $string): string\nMake a string uppercase',
	'strtr': '(string $string, string $from, string $to): string\nTranslate characters or replace substrings',
	'strtr': '(string $string, array $replace_pairs): string\nTranslate characters or replace substrings',
	'substr_compare': '(string $haystack, string $needle, int $offset, int|null $length = null, bool $case_insensitive = false): int\nBinary safe comparison of two strings from an offset, up to length characters',
	'substr_count': '(string $haystack, string $needle, int $offset = ?, int|null $length = null): int\nCount the number of substring occurrences',
	'substr_replace': '(array|string $string, array|string $replace, array|int $offset, array|int|null $length = null): string|array\nReplace text within a portion of a string',
	'substr': '(string $string, int $offset, int|null $length = null): string\nReturn part of a string',
	'trim': '(string $string, string $characters = " \\n\\r\\t\\v\\x00"): string\nStrip whitespace (or other characters) from the beginning and end of a string',
	'ucfirst': '(string $string): string\nMake a string\'s first character uppercase',
	'ucwords': '(string $string, string $separators = " \\t\\r\\n\\f\\v"): string\nUppercase the first character of each word in a string',
	'utf8_decode': '(string $string): string\nConverts a string from UTF-8 to ISO-8859-1, replacing invalid or unrepresentable characters',
	'utf8_encode': '(string $string): string\nConverts a string from ISO-8859-1 to UTF-8',
	'vfprintf': '(resource $stream, string $format, array $values): int\nWrite a formatted string to a stream',
	'vprintf': '(string $format, array $values): int\nOutput a formatted string',
	'vsprintf': '(string $format, array $values): string\nReturn a formatted string',
	'wordwrap': '(string $string, int $width = 75, string $break = "\\n", bool $cut_long_words = false): string\nWraps a string to a given number of characters',
	'base64_decode': '(string $string, bool $strict = false): string|false\nDecodes data encoded with MIME base64',
	'base64_encode': '(string $string): string\nEncodes data with MIME base64',
	'get_headers': '(string $url, bool $associative = false, resource|null $context = null): array|false\nFetches all the headers sent by the server in response to an HTTP request',
	'get_meta_tags': '(string $filename, bool $use_include_path = false): array|false\nExtracts all meta tag content attributes from a file and returns an array',
	'http_build_query': '(array|object $data, string $numeric_prefix = "", string|null $arg_separator = null, int $encoding_type = PHP_QUERY_RFC1738): string\nGenerate URL-encoded query string',
	'parse_url': '(string $url, int $component = -1): int|string|array|null|false\nParse a URL and return its components',
	'rawurldecode': '(string $string): string\nDecode URL-encoded strings',
	'rawurlencode': '(string $string): string\nURL-encode according to RFC 3986',
	'urldecode': '(string $string): string\nDecodes URL-encoded string',
	'urlencode': '(string $string): string\nURL-encodes string',
	'boolval': '(mixed $value): bool\nGet the boolean value of a variable',
	'debug_zval_dump': '(mixed $value, mixed ...$values): void\nDumps a string representation of an internal zval structure to output',
	'doubleval': 'Alias of floatval',
	'empty': '(mixed $var): bool\nDetermine whether a variable is empty',
	'floatval': '(mixed $value): float\nGet float value of a variable',
	'get_debug_type': '(mixed $value): string\nGets the type name of a variable in a way that is suitable for debugging',
	'get_defined_vars': '(): array\nReturns an array of all defined variables',
	'get_resource_id': '(resource $resource): int\nReturns an integer identifier for the given resource',
	'get_resource_type': '(resource $resource): string\nReturns the resource type',
	'gettype': '(mixed $value): string\nGet the type of a variable',
	'intval': '(mixed $value, int $base = 10): int\nGet the integer value of a variable',
	'is_array': '(mixed $value): bool\nFinds whether a variable is an array',
	'is_bool': '(mixed $value): bool\nFinds out whether a variable is a boolean',
	'is_callable': '(mixed $value, bool $syntax_only = false, string $callable_name = null): bool\nVerify that a value can be called as a function from the current scope',
	'is_countable': '(mixed $value): bool\nVerify that the contents of a variable is a countable value',
	'is_double': 'Alias of is_float',
	'is_float': '(mixed $value): bool\nFinds whether the type of a variable is float',
	'is_int': '(mixed $value): bool\nFind whether the type of a variable is integer',
	'is_integer': 'Alias of is_int',
	'is_iterable': '(mixed $value): bool\nVerify that the contents of a variable is an iterable value',
	'is_long': 'Alias of is_int',
	'is_null': '(mixed $value): bool\nFinds whether a variable is null',
	'is_numeric': '(mixed $value): bool\nFinds whether a variable is a number or a numeric string',
	'is_object': '(mixed $value): bool\nFinds whether a variable is an object',
	'is_real': 'Alias of is_float',
	'is_resource': '(mixed $value): bool\nFinds whether a variable is a resource',
	'is_scalar': '(mixed $value): bool\nFinds whether a variable is a scalar',
	'is_string': '(mixed $value): bool\nFind whether the type of a variable is string',
	'isset': '(mixed $var, mixed ...$vars): bool\nDetermine if a variable is declared and is different than null',
	'print_r': '(mixed $value, bool $return = false): string|true\nPrints human-readable information about a variable',
	'serialize': '(mixed $value): string\nGenerates a storable representation of a value',
	'settype': '(mixed $var, string $type): bool\nSet the type of a variable',
	'strval': '(mixed $value): string\nGet string value of a variable',
	'unserialize': '(string $data, array $options = []): mixed\nCreates a PHP value from a stored representation',
	'unset': '(mixed $var, mixed ...$vars): void\nUnset a given variable',
	'var_dump': '(mixed $value, mixed ...$values): void\nDumps information about a variable',
	'var_export': '(mixed $value, bool $return = false): string|null\nOutputs or returns a parsable string representation of a variable',
	'apache_child_terminate': '(): void\nTerminate apache process after this request',
	'apache_get_modules': '(): array\nGet a list of loaded Apache modules',
	'apache_get_version': '(): string|false\nFetch Apache version',
	'apache_getenv': '(string $variable, bool $walk_to_top = false): string|false\nGet an Apache subprocess_env variable',
	'apache_lookup_uri': '(string $filename): object|false\nPerform a partial request for the specified URI and return all info about it',
	'apache_note': '(string $note_name, string|null $note_value = null): string|false\nGet and set apache request notes',
	'apache_request_headers': '(): array\nFetch all HTTP request headers',
	'apache_response_headers': '(): array\nFetch all HTTP response headers',
	'apache_setenv': '(string $variable, string $value, bool $walk_to_top = false): bool\nSet an Apache subprocess_env variable',
	'getallheaders': '(): array\nFetch all HTTP request headers',
	'virtual': '(string $uri): bool\nPerform an Apache sub-request',
	'BcMath\\Number::add': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nAdds an arbitrary precision number',
	'BcMath\\Number::ceil': '(): BcMath\\Number\nRounds up an arbitrary precision number',
	'BcMath\\Number::compare': '(BcMath\\Number|string|int $num, int|null $scale = null): int\nCompares two arbitrary precision numbers',
	'BcMath\\Number::div': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nDivides by an arbitrary precision number',
	'BcMath\\Number::divmod': '(BcMath\\Number|string|int $num, int|null $scale = null): array\nGets the quotient and modulus of an arbitrary precision number',
	'BcMath\\Number::floor': '(): BcMath\\Number\nRounds down an arbitrary precision number',
	'BcMath\\Number::mod': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nGets the modulus of an arbitrary precision number',
	'BcMath\\Number::mul': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nMultiplies an arbitrary precision number',
	'BcMath\\Number::pow': '(BcMath\\Number|string|int $exponent, int|null $scale = null): BcMath\\Number\nRaises an arbitrary precision number',
	'BcMath\\Number::powmod': '(BcMath\\Number|string|int $exponent, BcMath\\Number|string|int $modulus, int|null $scale = null): BcMath\\Number\nRaises an arbitrary precision number, reduced by a specified modulus',
	'BcMath\\Number::round': '(int $precision = ?, RoundingMode $mode = RoundingMode::HalfAwayFromZero): BcMath\\Number\nRounds an arbitrary precision number',
	'BcMath\\Number::__serialize': '(): array\nSerializes a BcMath\\Number object',
	'BcMath\\Number::sqrt': '(int|null $scale = null): BcMath\\Number\nGets the square root of an arbitrary precision number',
	'BcMath\\Number::sub': '(BcMath\\Number|string|int $num, int|null $scale = null): BcMath\\Number\nSubtracts an arbitrary precision number',
	'BcMath\\Number::__toString': '(): string\nConverts BcMath\\Number to string',
	'BcMath\\Number::__unserialize': '(array $data): void\nDeserializes a data parameter into a BcMath\\Number object',
	'bcadd': '(string $num1, string $num2, int|null $scale = null): string\nAdd two arbitrary precision numbers',
	'bcceil': '(string $num): string\nRound up arbitrary precision number',
	'bccomp': '(string $num1, string $num2, int|null $scale = null): int\nCompare two arbitrary precision numbers',
	'bcdiv': '(string $num1, string $num2, int|null $scale = null): string\nDivide two arbitrary precision numbers',
	'bcdivmod': '(string $num1, string $num2, int|null $scale = null): array\nGet the quotient and modulus of an arbitrary precision number',
	'bcfloor': '(string $num): string\nRound down arbitrary precision number',
	'bcmod': '(string $num1, string $num2, int|null $scale = null): string\nGet modulus of an arbitrary precision number',
	'bcmul': '(string $num1, string $num2, int|null $scale = null): string\nMultiply two arbitrary precision numbers',
	'bcpow': '(string $num, string $exponent, int|null $scale = null): string\nRaise an arbitrary precision number to another',
	'bcpowmod': '(string $num, string $exponent, string $modulus, int|null $scale = null): string\nRaise an arbitrary precision number to another, reduced by a specified modulus',
	'bcround': '(string $num, int $precision = ?, RoundingMode $mode = RoundingMode::HalfAwayFromZero): string\nRound arbitrary precision number',
	'bcscale': '(int $scale): int\nSet or get default scale parameter for all bc math functions',
	'bcscale': '(null $scale = null): int\nSet or get default scale parameter for all bc math functions',
	'bcsqrt': '(string $num, int|null $scale = null): string\nGet the square root of an arbitrary precision number',
	'bcsub': '(string $num1, string $num2, int|null $scale = null): string\nSubtract one arbitrary precision number from another',
	'cal_days_in_month': '(int $calendar, int $month, int $year): int\nReturn the number of days in a month for a given year and calendar',
	'cal_from_jd': '(int $julian_day, int $calendar): array\nConverts from Julian Day Count to a supported calendar',
	'cal_info': '(int $calendar = -1): array\nReturns information about a particular calendar',
	'cal_to_jd': '(int $calendar, int $month, int $day, int $year): int\nConverts from a supported calendar to Julian Day Count',
	'easter_date': '(int|null $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet Unix timestamp for local midnight on Easter of a given year',
	'easter_days': '(int|null $year = null, int $mode = CAL_EASTER_DEFAULT): int\nGet number of days after March 21 on which Easter falls for a given year',
	'frenchtojd': '(int $month, int $day, int $year): int\nConverts a date from the French Republican Calendar to a Julian Day Count',
	'gregoriantojd': '(int $month, int $day, int $year): int\nConverts a Gregorian date to Julian Day Count',
	'jddayofweek': '(int $julian_day, int $mode = CAL_DOW_DAYNO): int|string\nReturns the day of the week',
	'jdmonthname': '(int $julian_day, int $mode): string\nReturns a month name',
	'jdtofrench': '(int $julian_day): string\nConverts a Julian Day Count to the French Republican Calendar',
	'jdtogregorian': '(int $julian_day): string\nConverts Julian Day Count to Gregorian date',
	'jdtojewish': '(int $julian_day, bool $hebrew = false, int $flags = ?): string\nConverts a Julian day count to a Jewish calendar date',
	'jdtojulian': '(int $julian_day): string\nConverts a Julian Day Count to a Julian Calendar Date',
	'jdtounix': '(int $julian_day): int\nConvert Julian Day to Unix timestamp',
	'jewishtojd': '(int $month, int $day, int $year): int\nConverts a date in the Jewish Calendar to Julian Day Count',
	'juliantojd': '(int $month, int $day, int $year): int\nConverts a Julian Calendar date to Julian Day Count',
	'unixtojd': '(int|null $timestamp = null): int|false\nConvert Unix timestamp to Julian Day',
	'COMPersistHelper::GetCurFileName': '(): string|false\nGet current filename',
	'COMPersistHelper::GetMaxStreamSize': '(): int\nGet maximum stream size',
	'COMPersistHelper::InitNew': '(): bool\nInitialize object to default state',
	'COMPersistHelper::LoadFromFile': '(string $filename, int $flags = ?): bool\nLoad object from file',
	'COMPersistHelper::LoadFromStream': '(resource $stream): bool\nLoad object from stream',
	'COMPersistHelper::SaveToFile': '(string|null $filename, bool $remember = true): bool\nSave object to file',
	'COMPersistHelper::SaveToStream': '(resource $stream): bool\nSave object to stream',
	'com_create_guid': '(): string|false\nGenerate a globally unique identifier (GUID)',
	'com_event_sink': '(variant $variant, object $sink_object, array|string|null $sink_interface = null): bool\nConnect events from a COM object to a PHP object',
	'com_get_active_object': '(string $prog_id, int|null $codepage = null): variant\nReturns a handle to an already running instance of a COM object',
	'com_load_typelib': '(string $typelib, bool $case_insensitive = true): bool\nLoads a Typelib',
	'com_message_pump': '(int $timeout_milliseconds = ?): bool\nProcess COM messages, sleeping for up to timeoutms milliseconds',
	'com_print_typeinfo': '(variant|string $variant, string|null $dispatch_interface = null, bool $display_sink = false): bool\nPrint out a PHP class definition for a dispatchable interface',
	'variant_abs': '(mixed $value): variant\nReturns the absolute value of a variant',
	'variant_add': '(mixed $left, mixed $right): variant\n"Adds" two variant values together and returns the result',
	'variant_and': '(mixed $left, mixed $right): variant\nPerforms a bitwise AND operation between two variants',
	'variant_cast': '(variant $variant, int $type): variant\nConvert a variant into a new variant object of another type',
	'variant_cat': '(mixed $left, mixed $right): variant\nConcatenates two variant values together and returns the result',
	'variant_cmp': '(mixed $left, mixed $right, int $locale_id = LOCALE_SYSTEM_DEFAULT, int $flags = ?): int\nCompares two variants',
	'variant_date_from_timestamp': '(int $timestamp): variant\nReturns a variant date representation of a Unix timestamp',
	'variant_date_to_timestamp': '(variant $variant): int|null\nConverts a variant date/time value to Unix timestamp',
	'variant_div': '(mixed $left, mixed $right): variant\nReturns the result from dividing two variants',
	'variant_eqv': '(mixed $left, mixed $right): variant\nPerforms a bitwise equivalence on two variants',
	'variant_fix': '(mixed $value): variant\nReturns the integer portion of a variant',
	'variant_get_type': '(variant $variant): int\nReturns the type of a variant object',
	'variant_idiv': '(mixed $left, mixed $right): variant\nConverts variants to integers and then returns the result from dividing them',
	'variant_imp': '(mixed $left, mixed $right): variant\nPerforms a bitwise implication on two variants',
	'variant_int': '(mixed $value): variant\nReturns the integer portion of a variant',
	'variant_mod': '(mixed $left, mixed $right): variant\nDivides two variants and returns only the remainder',
	'variant_mul': '(mixed $left, mixed $right): variant\nMultiplies the values of the two variants',
	'variant_neg': '(mixed $value): variant\nPerforms logical negation on a variant',
	'variant_not': '(mixed $value): variant\nPerforms bitwise not negation on a variant',
	'variant_or': '(mixed $left, mixed $right): variant\nPerforms a logical disjunction on two variants',
	'variant_pow': '(mixed $left, mixed $right): variant\nReturns the result of performing the power function with two variants',
	'variant_round': '(mixed $value, int $decimals): variant|null\nRounds a variant to the specified number of decimal places',
	'variant_set_type': '(variant $variant, int $type): void\nConvert a variant into another type "in-place"',
	'variant_set': '(variant $variant, mixed $value): void\nAssigns a new value for a variant object',
	'variant_sub': '(mixed $left, mixed $right): variant\nSubtracts the value of the right variant from the left variant value',
	'variant_xor': '(mixed $left, mixed $right): variant\nPerforms a logical exclusion on two variants',
	'ctype_alnum': '(mixed $text): bool\nCheck for alphanumeric character(s)',
	'ctype_alpha': '(mixed $text): bool\nCheck for alphabetic character(s)',
	'ctype_cntrl': '(mixed $text): bool\nCheck for control character(s)',
	'ctype_digit': '(mixed $text): bool\nCheck for numeric character(s)',
	'ctype_graph': '(mixed $text): bool\nCheck for any printable character(s) except space',
	'ctype_lower': '(mixed $text): bool\nCheck for lowercase character(s)',
	'ctype_print': '(mixed $text): bool\nCheck for printable character(s)',
	'ctype_punct': '(mixed $text): bool\nCheck for any printable character which is not whitespace or an alphanumeric character',
	'ctype_space': '(mixed $text): bool\nCheck for whitespace character(s)',
	'ctype_upper': '(mixed $text): bool\nCheck for uppercase character(s)',
	'ctype_xdigit': '(mixed $text): bool\nCheck for character(s) representing a hexadecimal digit',
	'dba_close': '(Dba\\Connection $dba): void\nClose a DBA database',
	'dba_delete': '(string|array $key, Dba\\Connection $dba): bool\nDelete DBA entry specified by key',
	'dba_exists': '(string|array $key, Dba\\Connection $dba): bool\nCheck whether key exists',
	'dba_fetch': '(string|array $key, Dba\\Connection $dba, int $skip = ?): string|false\nFetch data specified by key',
	'dba_fetch': '(string|array $key, int $skip, resource $dba): string\nFetch data specified by key',
	'dba_firstkey': '(Dba\\Connection $dba): string|false\nFetch first key',
	'dba_handlers': '(bool $full_info = false): array\nList all the handlers available',
	'dba_insert': '(string|array $key, string $value, Dba\\Connection $dba): bool\nInsert entry',
	'dba_key_split': '(string|false|null $key): array|false\nSplits a key in string representation into array representation',
	'dba_list': '(): array\nList all open database files',
	'dba_nextkey': '(Dba\\Connection $dba): string|false\nFetch next key',
	'dba_open': '(string $path, string $mode, string|null $handler = null, int $permission = 0644, int $map_size = ?, int|null $flags = null): Dba\\Connection|false\nOpen database',
	'dba_optimize': '(Dba\\Connection $dba): bool\nOptimize database',
	'dba_popen': '(string $path, string $mode, string|null $handler = null, int $permission = 0644, int $map_size = ?, int|null $flags = null): Dba\\Connection|false\nOpen database persistently',
	'dba_replace': '(string|array $key, string $value, Dba\\Connection $dba): bool\nReplace or insert entry',
	'dba_sync': '(Dba\\Connection $dba): bool\nSynchronize database',
	'exif_imagetype': '(string $filename): int|false\nDetermine the type of an image',
	'exif_read_data': '(resource|string $file, string|null $required_sections = null, bool $as_arrays = false, bool $read_thumbnail = false): array|false\nReads the EXIF headers from an image file',
	'exif_tagname': '(int $index): string|false\nGet the header name for an index',
	'exif_thumbnail': '(resource|string $file, int $width = null, int $height = null, int $image_type = null): string|false\nRetrieve the embedded thumbnail of an image',
	'read_exif_data': 'Alias of exif_read_data',
	'FFI\\CType::getAlignment': '(): int\nDescription',
	'FFI\\CType::getArrayElementType': '(): FFI\\CType\nDescription',
	'FFI\\CType::getArrayLength': '(): int\nDescription',
	'FFI\\CType::getAttributes': '(): int\nDescription',
	'FFI\\CType::getEnumKind': '(): int\nDescription',
	'FFI\\CType::getFuncABI': '(): int\nDescription',
	'FFI\\CType::getFuncParameterCount': '(): int\nRetrieve the count of parameters of a function type',
	'FFI\\CType::getFuncParameterType': '(int $index): FFI\\CType\nDescription',
	'FFI\\CType::getFuncReturnType': '(): FFI\\CType\nDescription',
	'FFI\\CType::getKind': '(): int\nDescription',
	'FFI\\CType::getName': '(): string\nDescription',
	'FFI\\CType::getPointerType': '(): FFI\\CType\nDescription',
	'FFI\\CType::getSize': '(): int\nDescription',
	'FFI\\CType::getStructFieldNames': '(): array\nDescription',
	'FFI\\CType::getStructFieldOffset': '(string $name): int\nDescription',
	'FFI\\CType::getStructFieldType': '(string $name): FFI\\CType\nDescription',
	'FFI::addr': '(FFI\\CData $ptr): FFI\\CData\nCreates an unmanaged pointer to C data',
	'FFI::alignof': '(FFI\\CData|FFI\\CType $ptr): int\nGets the alignment',
	'FFI::arrayType': '(FFI\\CType $type, array $dimensions): FFI\\CType\nDynamically constructs a new C array type',
	'FFI::cast': '(FFI\\CType|string $type, FFI\\CData|int|float|bool|null $ptr): FFI\\CData|null\nPerforms a C type cast',
	'FFI::cdef': '(string $code = "", string|null $lib = null): FFI\nCreates a new FFI object',
	'FFI::free': '(FFI\\CData $ptr): void\nReleases an unmanaged data structure',
	'FFI::isNull': '(FFI\\CData $ptr): bool\nChecks whether a FFI\\CData is a null pointer',
	'FFI::load': '(string $filename): FFI|null\nLoads C declarations from a C header file',
	'FFI::memcmp': '(string|FFI\\CData $ptr1, string|FFI\\CData $ptr2, int $size): int\nCompares memory areas',
	'FFI::memcpy': '(FFI\\CData $to, FFI\\CData|string $from, int $size): void\nCopies one memory area to another',
	'FFI::memset': '(FFI\\CData $ptr, int $value, int $size): void\nFills a memory area',
	'FFI::scope': '(string $name): FFI\nInstantiates an FFI object with C declarations parsed during preloading',
	'FFI::sizeof': '(FFI\\CData|FFI\\CType $ptr): int\nGets the size of C data or types',
	'FFI::string': '(FFI\\CData $ptr, int|null $size = null): string\nCreates a PHP string from a memory area',
	'FFI::type': '(string $type): FFI\\CType|null\nCreates an FFI\\CType object from a C declaration',
	'FFI::typeof': '(FFI\\CData $ptr): FFI\\CType\nGets the FFI\\CType of FFI\\CData',
	'finfo::buffer': '(string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nAlias finfo_buffer()',
	'finfo::file': '(string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nAlias finfo_file()',
	'finfo::set_flags': '(int $flags): true\nAlias finfo_set_flags()',
	'finfo_buffer': '(finfo $finfo, string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a string buffer',
	'finfo::buffer': '(string $string, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a string buffer',
	'finfo_close': '(finfo $finfo): bool\nClose finfo instance',
	'finfo_file': '(finfo $finfo, string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a file',
	'finfo::file': '(string $filename, int $flags = FILEINFO_NONE, resource|null $context = null): string|false\nReturn information about a file',
	'finfo_open': '(int $flags = FILEINFO_NONE, string|null $magic_database = null): finfo|false\nCreate a new finfo instance',
	'finfo_set_flags': '(finfo $finfo, int $flags): true\nSet libmagic configuration options',
	'finfo::set_flags': '(int $flags): true\nSet libmagic configuration options',
	'mime_content_type': '(resource|string $filename): string|false\nDetect MIME Content-type for a file',
	'filter_has_var': '(int $input_type, string $var_name): bool\nChecks if variable of specified type exists',
	'filter_id': '(string $name): int|false\nReturns the filter ID belonging to a named filter',
	'filter_input_array': '(int $type, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets external variables and optionally filters them',
	'filter_input': '(int $type, string $var_name, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nGets a specific external variable by name and optionally filters it',
	'filter_list': '(): array\nReturns a list of all supported filters',
	'filter_var_array': '(array $array, array|int $options = FILTER_DEFAULT, bool $add_empty = true): array|false|null\nGets multiple variables and optionally filters them',
	'filter_var': '(mixed $value, int $filter = FILTER_DEFAULT, array|int $options = ?): mixed\nFilters a variable with a specified filter',
	'ftp_alloc': '(FTP\\Connection $ftp, int $size, string $response = null): bool\nAllocates space for a file to be uploaded',
	'ftp_append': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY): bool\nAppend the contents of a file to another file on the FTP server',
	'ftp_cdup': '(FTP\\Connection $ftp): bool\nChanges to the parent directory',
	'ftp_chdir': '(FTP\\Connection $ftp, string $directory): bool\nChanges the current directory on a FTP server',
	'ftp_chmod': '(FTP\\Connection $ftp, int $permissions, string $filename): int|false\nSet permissions on a file via FTP',
	'ftp_close': '(FTP\\Connection $ftp): bool\nCloses an FTP connection',
	'ftp_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens an FTP connection',
	'ftp_delete': '(FTP\\Connection $ftp, string $filename): bool\nDeletes a file on the FTP server',
	'ftp_exec': '(FTP\\Connection $ftp, string $command): bool\nRequests execution of a command on the FTP server',
	'ftp_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server and saves to an open file',
	'ftp_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads from an open file to the FTP server',
	'ftp_get_option': '(FTP\\Connection $ftp, int $option): int|bool\nRetrieves various runtime behaviours of the current FTP connection',
	'ftp_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nDownloads a file from the FTP server',
	'ftp_login': '(FTP\\Connection $ftp, string $username, string $password): bool\nLogs in to an FTP connection',
	'ftp_mdtm': '(FTP\\Connection $ftp, string $filename): int\nReturns the last modified time of the given file',
	'ftp_mkdir': '(FTP\\Connection $ftp, string $directory): string|false\nCreates a directory',
	'ftp_mlsd': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
	'ftp_nb_continue': '(FTP\\Connection $ftp): int\nContinues retrieving/sending a file (non-blocking)',
	'ftp_nb_fget': '(FTP\\Connection $ftp, resource $stream, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int\nRetrieves a file from the FTP server and writes it to an open file (non-blocking)',
	'ftp_nb_fput': '(FTP\\Connection $ftp, string $remote_filename, resource $stream, int $mode = FTP_BINARY, int $offset = ?): int\nStores a file from an open file to the FTP server (non-blocking)',
	'ftp_nb_get': '(FTP\\Connection $ftp, string $local_filename, string $remote_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nRetrieves a file from the FTP server and writes it to a local file (non-blocking)',
	'ftp_nb_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): int|false\nStores a file on the FTP server (non-blocking)',
	'ftp_nlist': '(FTP\\Connection $ftp, string $directory): array|false\nReturns a list of files in the given directory',
	'ftp_pasv': '(FTP\\Connection $ftp, bool $enable): bool\nTurns passive mode on or off',
	'ftp_put': '(FTP\\Connection $ftp, string $remote_filename, string $local_filename, int $mode = FTP_BINARY, int $offset = ?): bool\nUploads a file to the FTP server',
	'ftp_pwd': '(FTP\\Connection $ftp): string|false\nReturns the current directory name',
	'ftp_quit': 'Alias of ftp_close',
	'ftp_raw': '(FTP\\Connection $ftp, string $command): array|null\nSends an arbitrary command to an FTP server',
	'ftp_rawlist': '(FTP\\Connection $ftp, string $directory, bool $recursive = false): array|false\nReturns a detailed list of files in the given directory',
	'ftp_rename': '(FTP\\Connection $ftp, string $from, string $to): bool\nRenames a file or a directory on the FTP server',
	'ftp_rmdir': '(FTP\\Connection $ftp, string $directory): bool\nRemoves a directory',
	'ftp_set_option': '(FTP\\Connection $ftp, int $option, int|bool $value): bool\nSet miscellaneous runtime FTP options',
	'ftp_site': '(FTP\\Connection $ftp, string $command): bool\nSends a SITE command to the server',
	'ftp_size': '(FTP\\Connection $ftp, string $filename): int\nReturns the size of the given file',
	'ftp_ssl_connect': '(string $hostname, int $port = 21, int $timeout = 90): FTP\\Connection|false\nOpens a Secure SSL-FTP connection',
	'ftp_systype': '(FTP\\Connection $ftp): string|false\nReturns the system type identifier of the remote FTP server',
	'iconv_get_encoding': '(string $type = "all"): array|string|false\nRetrieve internal configuration variables of iconv extension',
	'iconv_mime_decode_headers': '(string $headers, int $mode = ?, string|null $encoding = null): array|false\nDecodes multiple MIME header fields at once',
	'iconv_mime_decode': '(string $string, int $mode = ?, string|null $encoding = null): string|false\nDecodes a MIME header field',
	'iconv_mime_encode': '(string $field_name, string $field_value, array $options = []): string|false\nComposes a MIME header field',
	'iconv_set_encoding': '(string $type, string $encoding): bool\nSet current setting for character encoding conversion',
	'iconv_strlen': '(string $string, string|null $encoding = null): int|false\nReturns the character count of string',
	'iconv_strpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of first occurrence of a needle within a haystack',
	'iconv_strrpos': '(string $haystack, string $needle, string|null $encoding = null): int|false\nFinds the last occurrence of a needle within a haystack',
	'iconv_substr': '(string $string, int $offset, int|null $length = null, string|null $encoding = null): string|false\nCut out part of a string',
	'iconv': '(string $from_encoding, string $to_encoding, string $string): string|false\nConvert a string from one character encoding to another',
	'ob_iconv_handler': '(string $contents, int $status): string\nConvert character encoding as output buffer handler',
	'gd_info': '(): array\nRetrieve information about the currently installed GD library',
	'getimagesize': '(string $filename, array $image_info = null): array|false\nGet the size of an image',
	'getimagesizefromstring': '(string $string, array $image_info = null): array|false\nGet the size of an image from a string',
	'image_type_to_extension': '(int $image_type, bool $include_dot = true): string|false\nGet file extension for image type',
	'image_type_to_mime_type': '(int $image_type): string\nGet Mime-Type for image-type returned by getimagesize, exif_read_data, exif_thumbnail, exif_imagetype',
	'image2wbmp': '(resource $image, string $filename = ?, int $foreground = ?): bool\ngd.image.output',
	'imageaffine': '(GdImage $image, array $affine, array|null $clip = null): GdImage|false\nReturn an image containing the affine transformed src image, using an optional clipping area',
	'imageaffinematrixconcat': '(array $matrix1, array $matrix2): array|false\nConcatenate two affine transformation matrices',
	'imageaffinematrixget': '(int $type, array|float $options): array|false\nGet an affine transformation matrix',
	'imagealphablending': '(GdImage $image, bool $enable): bool\nSet the blending mode for an image',
	'imageantialias': '(GdImage $image, bool $enable): bool\nShould antialias functions be used or not',
	'imagearc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color): bool\nDraws an arc',
	'imageavif': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $speed = -1): bool\ngd.image.output',
	'imagebmp': '(GdImage $image, resource|string|null $file = null, bool $compressed = true): bool\nOutput a BMP image to browser or file',
	'imagechar': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): bool\nDraw a character horizontally',
	'imagecharup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $char, int $color): bool\nDraw a character vertically',
	'imagecolorallocate': '(GdImage $image, int $red, int $green, int $blue): int|false\nAllocate a color for an image',
	'imagecolorallocatealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int|false\nAllocate a color for an image',
	'imagecolorat': '(GdImage $image, int $x, int $y): int|false\nGet the index of the color of a pixel',
	'imagecolorclosest': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the closest color to the specified color',
	'imagecolorclosestalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the closest color to the specified color + alpha',
	'imagecolorclosesthwb': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the color which has the hue, white and blackness',
	'imagecolordeallocate': '(GdImage $image, int $color): bool\nDe-allocate a color for an image',
	'imagecolorexact': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color',
	'imagecolorexactalpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha',
	'imagecolormatch': '(GdImage $image1, GdImage $image2): bool\nMakes the colors of the palette version of an image more closely match the true color version',
	'imagecolorresolve': '(GdImage $image, int $red, int $green, int $blue): int\nGet the index of the specified color or its closest possible alternative',
	'imagecolorresolvealpha': '(GdImage $image, int $red, int $green, int $blue, int $alpha): int\nGet the index of the specified color + alpha or its closest possible alternative',
	'imagecolorset': '(GdImage $image, int $color, int $red, int $green, int $blue, int $alpha = ?): false|null\nSet the color for the specified palette index',
	'imagecolorsforindex': '(GdImage $image, int $color): array\nGet the colors for an index',
	'imagecolorstotal': '(GdImage $image): int\nFind out the number of colors in an image\'s palette',
	'imagecolortransparent': '(GdImage $image, int|null $color = null): int\nDefine a color as transparent',
	'imageconvolution': '(GdImage $image, array $matrix, float $divisor, float $offset): bool\nApply a 3x3 convolution matrix, using coefficient and offset',
	'imagecopy': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height): bool\nCopy part of an image',
	'imagecopymerge': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): bool\nCopy and merge part of an image',
	'imagecopymergegray': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $src_width, int $src_height, int $pct): bool\nCopy and merge part of an image with gray scale',
	'imagecopyresampled': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): bool\nCopy and resize part of an image with resampling',
	'imagecopyresized': '(GdImage $dst_image, GdImage $src_image, int $dst_x, int $dst_y, int $src_x, int $src_y, int $dst_width, int $dst_height, int $src_width, int $src_height): bool\nCopy and resize part of an image',
	'imagecreate': '(int $width, int $height): GdImage|false\nCreate a new palette based image',
	'imagecreatefromavif': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefrombmp': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromgd': '(string $filename): GdImage|false\nCreate a new image from GD file or URL',
	'imagecreatefromgd2': '(string $filename): GdImage|false\nCreate a new image from GD2 file or URL',
	'imagecreatefromgd2part': '(string $filename, int $x, int $y, int $width, int $height): GdImage|false\nCreate a new image from a given part of GD2 file or URL',
	'imagecreatefromgif': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromjpeg': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefrompng': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromstring': '(string $data): GdImage|false\nCreate a new image from the image stream in the string',
	'imagecreatefromtga': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromwbmp': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromwebp': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromxbm': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatefromxpm': '(string $filename): GdImage|false\ngd.image.new',
	'imagecreatetruecolor': '(int $width, int $height): GdImage|false\nCreate a new true color image',
	'imagecrop': '(GdImage $image, array $rectangle): GdImage|false\nCrop an image to the given rectangle',
	'imagecropauto': '(GdImage $image, int $mode = IMG_CROP_DEFAULT, float $threshold = 0.5, int $color = -1): GdImage|false\nCrop an image automatically using one of the available modes',
	'imagedashedline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a dashed line',
	'imagedestroy': '(GdImage $image): bool\nDestroy an image',
	'imageellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool\nDraw an ellipse',
	'imagefill': '(GdImage $image, int $x, int $y, int $color): bool\nFlood fill',
	'imagefilledarc': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $start_angle, int $end_angle, int $color, int $style): bool\nDraw a partial arc and fill it',
	'imagefilledellipse': '(GdImage $image, int $center_x, int $center_y, int $width, int $height, int $color): bool\nDraw a filled ellipse',
	'imagefilledpolygon': '(GdImage $image, array $points, int $color): bool\nDraw a filled polygon',
	'imagefilledpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraw a filled polygon',
	'imagefilledrectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a filled rectangle',
	'imagefilltoborder': '(GdImage $image, int $x, int $y, int $border_color, int $color): bool\nFlood fill to specific color',
	'imagefilter': '(GdImage $image, int $filter, array|int|float|bool ...$args): bool\nApplies a filter to an image',
	'imageflip': '(GdImage $image, int $mode): bool\nFlips an image using a given mode',
	'imagefontheight': '(GdFont|int $font): int\nGet font height',
	'imagefontwidth': '(GdFont|int $font): int\nGet font width',
	'imageftbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using fonts via freetype2',
	'imagefttext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using fonts using FreeType 2',
	'imagegammacorrect': '(GdImage $image, float $input_gamma, float $output_gamma): bool\nApply a gamma correction to a GD image',
	'imagegd': '(GdImage $image, string|null $file = null): bool\nOutput GD image to browser or file',
	'imagegd2': '(GdImage $image, string|null $file = null, int $chunk_size = 128, int $mode = IMG_GD2_RAW): bool\nOutput GD2 image to browser or file',
	'imagegetclip': '(GdImage $image): array\nGet the clipping rectangle',
	'imagegetinterpolation': '(GdImage $image): int\nGet the interpolation method',
	'imagegif': '(GdImage $image, resource|string|null $file = null): bool\ngd.image.output',
	'imagegrabscreen': '(): GdImage|false\nCaptures the whole screen',
	'imagegrabwindow': '(int $handle, bool $client_area = false): GdImage|false\nCaptures a window',
	'imageinterlace': '(GdImage $image, bool|null $enable = null): bool\nEnable or disable interlace',
	'imageistruecolor': '(GdImage $image): bool\nFinds whether an image is a truecolor image',
	'imagejpeg': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\ngd.image.output',
	'imagelayereffect': '(GdImage $image, int $effect): bool\nSet the alpha blending flag to use layering effects',
	'imageline': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a line',
	'imageloadfont': '(string $filename): GdFont|false\nLoad a new font',
	'imageopenpolygon': '(GdImage $image, array $points, int $color): bool\nDraws an open polygon',
	'imageopenpolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws an open polygon',
	'imagepalettecopy': '(GdImage $dst, GdImage $src): void\nCopy the palette from one image to another',
	'imagepalettetotruecolor': '(GdImage $image): bool\nConverts a palette based image to true color',
	'imagepng': '(GdImage $image, resource|string|null $file = null, int $quality = -1, int $filters = -1): bool\nOutput a PNG image to either the browser or a file',
	'imagepolygon': '(GdImage $image, array $points, int $color): bool\nDraws a polygon',
	'imagepolygon': '(GdImage $image, array $points, int $num_points, int $color): bool\nDraws a polygon',
	'imagerectangle': '(GdImage $image, int $x1, int $y1, int $x2, int $y2, int $color): bool\nDraw a rectangle',
	'imageresolution': '(GdImage $image, int|null $resolution_x = null, int|null $resolution_y = null): array|bool\nGet or set the resolution of the image',
	'imagerotate': '(GdImage $image, float $angle, int $background_color): GdImage|false\nRotate an image with a given angle',
	'imagesavealpha': '(GdImage $image, bool $enable): bool\nWhether to retain full alpha channel information when saving images',
	'imagescale': '(GdImage $image, int $width, int $height = -1, int $mode = IMG_BILINEAR_FIXED): GdImage|false\nScale an image using the given new width and height',
	'imagesetbrush': '(GdImage $image, GdImage $brush): bool\nSet the brush image for line drawing',
	'imagesetclip': '(GdImage $image, int $x1, int $y1, int $x2, int $y2): bool\nSet the clipping rectangle',
	'imagesetinterpolation': '(GdImage $image, int $method = IMG_BILINEAR_FIXED): bool\nSet the interpolation method',
	'imagesetpixel': '(GdImage $image, int $x, int $y, int $color): bool\nSet a single pixel',
	'imagesetstyle': '(GdImage $image, array $style): bool\nSet the style for line drawing',
	'imagesetthickness': '(GdImage $image, int $thickness): bool\nSet the thickness for line drawing',
	'imagesettile': '(GdImage $image, GdImage $tile): bool\nSet the tile image for filling',
	'imagestring': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): bool\nDraw a string horizontally',
	'imagestringup': '(GdImage $image, GdFont|int $font, int $x, int $y, string $string, int $color): bool\nDraw a string vertically',
	'imagesx': '(GdImage $image): int\nGet image width',
	'imagesy': '(GdImage $image): int\nGet image height',
	'imagetruecolortopalette': '(GdImage $image, bool $dither, int $num_colors): bool\nConvert a true color image to a palette image',
	'imagettfbbox': '(float $size, float $angle, string $font_filename, string $string, array $options = []): array|false\nGive the bounding box of a text using TrueType fonts',
	'imagettftext': '(GdImage $image, float $size, float $angle, int $x, int $y, int $color, string $font_filename, string $text, array $options = []): array|false\nWrite text to the image using TrueType fonts',
	'imagetypes': '(): int\nReturn the image types supported by this PHP build',
	'imagewbmp': '(GdImage $image, resource|string|null $file = null, int|null $foreground_color = null): bool\ngd.image.output',
	'imagewebp': '(GdImage $image, resource|string|null $file = null, int $quality = -1): bool\nOutput a WebP image to browser or file',
	'imagexbm': '(GdImage $image, string|null $filename, int|null $foreground_color = null): bool\nOutput an XBM image to browser or file',
	'iptcembed': '(string $iptc_data, string $filename, int $spool = ?): string|bool\nEmbeds binary IPTC data into a JPEG image',
	'iptcparse': '(string $iptc_block): array|false\nParse a binary IPTC block into single tags',
	'jpeg2wbmp': '(string $jpegname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert JPEG image file to WBMP image file',
	'png2wbmp': '(string $pngname, string $wbmpname, int $dest_height, int $dest_width, int $threshold): bool\nConvert PNG image file to WBMP image file',
	'Collator::asort': '(array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array maintaining index association',
	'collator_asort': '(Collator $object, array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array maintaining index association',
	'Collator::compare': '(string $string1, string $string2): int|false\nCompare two Unicode strings',
	'collator_compare': '(Collator $object, string $string1, string $string2): int|false\nCompare two Unicode strings',
	'Collator::create': '(string $locale): Collator|null\nCreate a collator',
	'collator_create': '(string $locale): Collator|null\nCreate a collator',
	'Collator::getAttribute': '(int $attribute): int|false\nGet collation attribute value',
	'collator_get_attribute': '(Collator $object, int $attribute): int|false\nGet collation attribute value',
	'Collator::getErrorCode': '(): int|false\nGet collator\'s last error code',
	'collator_get_error_code': '(Collator $object): int|false\nGet collator\'s last error code',
	'Collator::getErrorMessage': '(): string|false\nGet text for collator\'s last error code',
	'collator_get_error_message': '(Collator $object): string|false\nGet text for collator\'s last error code',
	'Collator::getLocale': '(int $type): string|false\nGet the locale name of the collator',
	'collator_get_locale': '(Collator $object, int $type): string|false\nGet the locale name of the collator',
	'Collator::getSortKey': '(string $string): string|false\nGet sorting key for a string',
	'collator_get_sort_key': '(Collator $object, string $string): string|false\nGet sorting key for a string',
	'Collator::getStrength': '(): int\nGet current collation strength',
	'collator_get_strength': '(Collator $object): int\nGet current collation strength',
	'Collator::setAttribute': '(int $attribute, int $value): bool\nSet collation attribute',
	'collator_set_attribute': '(Collator $object, int $attribute, int $value): bool\nSet collation attribute',
	'Collator::setStrength': '(int $strength): true\nSet collation strength',
	'collator_set_strength': '(Collator $object, int $strength): true\nSet collation strength',
	'Collator::sortWithSortKeys': '(array $array): bool\nSort array using specified collator and sort keys',
	'collator_sort_with_sort_keys': '(Collator $object, array $array): bool\nSort array using specified collator and sort keys',
	'Collator::sort': '(array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array using specified collator',
	'collator_sort': '(Collator $object, array $array, int $flags = Collator::SORT_REGULAR): bool\nSort array using specified collator',
	'IntlDateFormatter::create': '(string|null $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, string|null $pattern = null): IntlDateFormatter|null\nCreate a date formatter',
	'datefmt_create': '(string|null $locale, int $dateType = IntlDateFormatter::FULL, int $timeType = IntlDateFormatter::FULL, IntlTimeZone|DateTimeZone|string|null $timezone = null, IntlCalendar|int|null $calendar = null, string|null $pattern = null): IntlDateFormatter|null\nCreate a date formatter',
	'IntlDateFormatter::format': '(IntlCalendar|DateTimeInterface|array|string|int|float $datetime): string|false\nFormat the date/time value as a string',
	'datefmt_format': '(IntlDateFormatter $formatter, IntlCalendar|DateTimeInterface|array|string|int|float $datetime): string|false\nFormat the date/time value as a string',
	'IntlDateFormatter::formatObject': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, string|null $locale = null): string|false\nFormats an object',
	'datefmt_format_object': '(IntlCalendar|DateTimeInterface $datetime, array|int|string|null $format = null, string|null $locale = null): string|false\nFormats an object',
	'IntlDateFormatter::getCalendar': '(): int|false\nGet the calendar type used for the IntlDateFormatter',
	'datefmt_get_calendar': '(IntlDateFormatter $formatter): int|false\nGet the calendar type used for the IntlDateFormatter',
	'IntlDateFormatter::getDateType': '(): int|false\nGet the datetype used for the IntlDateFormatter',
	'datefmt_get_datetype': '(IntlDateFormatter $formatter): int|false\nGet the datetype used for the IntlDateFormatter',
	'IntlDateFormatter::getErrorCode': '(): int\nGet the error code from last operation',
	'datefmt_get_error_code': '(IntlDateFormatter $formatter): int\nGet the error code from last operation',
	'IntlDateFormatter::getErrorMessage': '(): string\nGet the error text from the last operation',
	'datefmt_get_error_message': '(IntlDateFormatter $formatter): string\nGet the error text from the last operation',
	'IntlDateFormatter::getLocale': '(int $type = ULOC_ACTUAL_LOCALE): string|false\nGet the locale used by formatter',
	'datefmt_get_locale': '(IntlDateFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet the locale used by formatter',
	'IntlDateFormatter::getPattern': '(): string|false\nGet the pattern used for the IntlDateFormatter',
	'datefmt_get_pattern': '(IntlDateFormatter $formatter): string|false\nGet the pattern used for the IntlDateFormatter',
	'IntlDateFormatter::getTimeType': '(): int|false\nGet the timetype used for the IntlDateFormatter',
	'datefmt_get_timetype': '(IntlDateFormatter $formatter): int|false\nGet the timetype used for the IntlDateFormatter',
	'IntlDateFormatter::getTimeZoneId': '(): string|false\nGet the timezone-id used for the IntlDateFormatter',
	'datefmt_get_timezone_id': '(IntlDateFormatter $formatter): string|false\nGet the timezone-id used for the IntlDateFormatter',
	'IntlDateFormatter::getCalendarObject': '(): IntlCalendar|false|null\nGet copy of formatterʼs calendar object',
	'datefmt_get_calendar_object': '(IntlDateFormatter $formatter): IntlCalendar|false|null\nGet copy of formatterʼs calendar object',
	'IntlDateFormatter::getTimeZone': '(): IntlTimeZone|false\nGet formatterʼs timezone',
	'datefmt_get_timezone': '(IntlDateFormatter $formatter): IntlTimeZone|false\nGet formatterʼs timezone',
	'IntlDateFormatter::isLenient': '(): bool\nGet the lenient used for the IntlDateFormatter',
	'datefmt_is_lenient': '(IntlDateFormatter $formatter): bool\nGet the lenient used for the IntlDateFormatter',
	'IntlDateFormatter::localtime': '(string $string, int $offset = null): array|false\nParse string to a field-based time value',
	'datefmt_localtime': '(IntlDateFormatter $formatter, string $string, int $offset = null): array|false\nParse string to a field-based time value',
	'IntlDateFormatter::parse': '(string $string, int $offset = null): int|float|false\nParse string to a timestamp value',
	'datefmt_parse': '(IntlDateFormatter $formatter, string $string, int $offset = null): int|float|false\nParse string to a timestamp value',
	'IntlDateFormatter::setCalendar': '(IntlCalendar|int|null $calendar): bool\nSets the calendar type used by the formatter',
	'datefmt_set_calendar': '(IntlDateFormatter $formatter, IntlCalendar|int|null $calendar): bool\nSets the calendar type used by the formatter',
	'IntlDateFormatter::setLenient': '(bool $lenient): void\nSet the leniency of the parser',
	'datefmt_set_lenient': '(IntlDateFormatter $formatter, bool $lenient): void\nSet the leniency of the parser',
	'IntlDateFormatter::setPattern': '(string $pattern): bool\nSet the pattern used for the IntlDateFormatter',
	'datefmt_set_pattern': '(IntlDateFormatter $formatter, string $pattern): bool\nSet the pattern used for the IntlDateFormatter',
	'IntlDateFormatter::setTimeZone': '(IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSets formatterʼs timezone',
	'datefmt_set_timezone': '(IntlDateFormatter $formatter, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSets formatterʼs timezone',
	'intl_error_name': '(int $errorCode): string\nGet symbolic name for a given error code',
	'intl_get_error_code': '(): int\nGet the last error code',
	'intl_get_error_message': '(): string\nGet description of the last error',
	'intl_is_failure': '(int $errorCode): bool\nCheck whether the given error code indicates failure',
	'grapheme_extract': '(string $haystack, int $size, int $type = GRAPHEME_EXTR_COUNT, int $offset = ?, int $next = null): string|false\nFunction to extract a sequence of default grapheme clusters from a text buffer, which must be encoded in UTF-8',
	'grapheme_str_split': '(string $string, int $length = 1): array|false\nSplit a string into an array',
	'grapheme_stripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of first occurrence of a case-insensitive string',
	'grapheme_stristr': '(string $haystack, string $needle, bool $beforeNeedle = false): string|false\nReturns part of haystack string from the first occurrence of case-insensitive needle to the end of haystack',
	'grapheme_strlen': '(string $string): int|false|null\nGet string length in grapheme units',
	'grapheme_strpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of first occurrence of a string',
	'grapheme_strripos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of last occurrence of a case-insensitive string',
	'grapheme_strrpos': '(string $haystack, string $needle, int $offset = ?): int|false\nFind position (in grapheme units) of last occurrence of a string',
	'grapheme_strstr': '(string $haystack, string $needle, bool $beforeNeedle = false): string|false\nReturns part of haystack string from the first occurrence of needle to the end of haystack',
	'grapheme_substr': '(string $string, int $offset, int|null $length = null): string|false\nReturn part of a string',
	'idn_to_ascii': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array $idna_info = null): string|false\nConvert domain name to IDNA ASCII form',
	'idn_to_utf8': '(string $domain, int $flags = IDNA_DEFAULT, int $variant = INTL_IDNA_VARIANT_UTS46, array $idna_info = null): string|false\nConvert domain name from IDNA ASCII to Unicode',
	'IntlBreakIterator::createCharacterInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for boundaries of combining character sequences',
	'IntlBreakIterator::createCodePointInstance': '(): IntlCodePointBreakIterator\nCreate break iterator for boundaries of code points',
	'IntlBreakIterator::createLineInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for logically possible line breaks',
	'IntlBreakIterator::createSentenceInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for sentence breaks',
	'IntlBreakIterator::createTitleInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for title-casing breaks',
	'IntlBreakIterator::createWordInstance': '(string|null $locale = null): IntlBreakIterator|null\nCreate break iterator for word breaks',
	'IntlBreakIterator::current': '(): int\nGet index of current position',
	'IntlBreakIterator::first': '(): int\nSet position to the first character in the text',
	'IntlBreakIterator::following': '(int $offset): int\nAdvance the iterator to the first boundary following specified offset',
	'IntlBreakIterator::getErrorCode': '(): int\nGet last error code on the object',
	'intl_get_error_code': '(): int\nGet last error code on the object',
	'IntlBreakIterator::getErrorMessage': '(): string\nGet last error message on the object',
	'intl_get_error_message': '(): string\nGet last error message on the object',
	'IntlBreakIterator::getLocale': '(int $type): string|false\nGet the locale associated with the object',
	'IntlBreakIterator::getPartsIterator': '(string $type = IntlPartsIterator::KEY_SEQUENTIAL): IntlPartsIterator\nCreate iterator for navigating fragments between boundaries',
	'IntlBreakIterator::getText': '(): string|null\nGet the text being scanned',
	'IntlBreakIterator::isBoundary': '(int $offset): bool\nTell whether an offset is a boundaryʼs offset',
	'IntlBreakIterator::last': '(): int\nSet the iterator position to index beyond the last character',
	'IntlBreakIterator::next': '(int|null $offset = null): int\nAdvance the iterator the next boundary',
	'IntlBreakIterator::preceding': '(int $offset): int\nSet the iterator position to the first boundary before an offset',
	'IntlBreakIterator::previous': '(): int\nSet the iterator position to the boundary immediately before the current',
	'IntlBreakIterator::setText': '(string $text): bool\nSet the text being scanned',
	'IntlCalendar::add': '(int $field, int $value): bool\nAdd a (signed) amount of time to a field',
	'intlcal_add': '(IntlCalendar $calendar, int $field, int $value): bool\nAdd a (signed) amount of time to a field',
	'IntlCalendar::after': '(IntlCalendar $other): bool\nWhether this objectʼs time is after that of the passed object',
	'intlcal_after': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is after that of the passed object',
	'IntlCalendar::before': '(IntlCalendar $other): bool\nWhether this objectʼs time is before that of the passed object',
	'intlcal_before': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether this objectʼs time is before that of the passed object',
	'IntlCalendar::clear': '(int|null $field = null): true\nClear a field or all fields',
	'intlcal_clear': '(IntlCalendar $calendar, int|null $field = null): true\nClear a field or all fields',
	'IntlCalendar::createInstance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, string|null $locale = null): IntlCalendar|null\nCreate a new IntlCalendar',
	'intlcal_create_instance': '(IntlTimeZone|DateTimeZone|string|null $timezone = null, string|null $locale = null): IntlCalendar|null\nCreate a new IntlCalendar',
	'IntlCalendar::equals': '(IntlCalendar $other): bool\nCompare time of two IntlCalendar objects for equality',
	'intlcal_equals': '(IntlCalendar $calendar, IntlCalendar $other): bool\nCompare time of two IntlCalendar objects for equality',
	'IntlCalendar::fieldDifference': '(float $timestamp, int $field): int|false\nCalculate difference between given time and this objectʼs time',
	'intlcal_field_difference': '(IntlCalendar $calendar, float $timestamp, int $field): int|false\nCalculate difference between given time and this objectʼs time',
	'IntlCalendar::fromDateTime': '(DateTime|string $datetime, string|null $locale = null): IntlCalendar|null\nCreate an IntlCalendar from a DateTime object or string',
	'intlcal_from_date_time': '(DateTime|string $datetime, string|null $locale = null): IntlCalendar|null\nCreate an IntlCalendar from a DateTime object or string',
	'IntlCalendar::get': '(int $field): int|false\nGet the value for a field',
	'intlcal_get': '(IntlCalendar $calendar, int $field): int|false\nGet the value for a field',
	'IntlCalendar::getActualMaximum': '(int $field): int|false\nThe maximum value for a field, considering the objectʼs current time',
	'intlcal_get_actual_maximum': '(IntlCalendar $calendar, int $field): int|false\nThe maximum value for a field, considering the objectʼs current time',
	'IntlCalendar::getActualMinimum': '(int $field): int|false\nThe minimum value for a field, considering the objectʼs current time',
	'intlcal_get_actual_minimum': '(IntlCalendar $calendar, int $field): int|false\nThe minimum value for a field, considering the objectʼs current time',
	'IntlCalendar::getAvailableLocales': '(): array\nGet array of locales for which there is data',
	'intlcal_get_available_locales': '(): array\nGet array of locales for which there is data',
	'IntlCalendar::getDayOfWeekType': '(int $dayOfWeek): int|false\nTell whether a day is a weekday, weekend or a day that has a transition between the two',
	'intlcal_get_day_of_week_type': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nTell whether a day is a weekday, weekend or a day that has a transition between the two',
	'IntlCalendar::getErrorCode': '(): int|false\nGet last error code on the object',
	'intlcal_get_error_code': '(IntlCalendar $calendar): int|false\nGet last error code on the object',
	'IntlCalendar::getErrorMessage': '(): string|false\nGet last error message on the object',
	'intlcal_get_error_message': '(IntlCalendar $calendar): string|false\nGet last error message on the object',
	'IntlCalendar::getFirstDayOfWeek': '(): int|false\nGet the first day of the week for the calendarʼs locale',
	'intlcal_get_first_day_of_week': '(IntlCalendar $calendar): int|false\nGet the first day of the week for the calendarʼs locale',
	'IntlCalendar::getGreatestMinimum': '(int $field): int|false\nGet the largest local minimum value for a field',
	'intlcal_get_greatest_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the largest local minimum value for a field',
	'IntlCalendar::getKeywordValuesForLocale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
	'intlcal_get_keyword_values_for_locale': '(string $keyword, string $locale, bool $onlyCommon): IntlIterator|false\nGet set of locale keyword values',
	'IntlCalendar::getLeastMaximum': '(int $field): int|false\nGet the smallest local maximum for a field',
	'intlcal_get_least_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the smallest local maximum for a field',
	'IntlCalendar::getLocale': '(int $type): string|false\nGet the locale associated with the object',
	'intlcal_get_locale': '(IntlCalendar $calendar, int $type): string|false\nGet the locale associated with the object',
	'IntlCalendar::getMaximum': '(int $field): int|false\nGet the global maximum value for a field',
	'intlcal_get_maximum': '(IntlCalendar $calendar, int $field): int|false\nGet the global maximum value for a field',
	'IntlCalendar::getMinimalDaysInFirstWeek': '(): int|false\nGet minimal number of days the first week in a year or month can have',
	'intlcal_get_minimal_days_in_first_week': '(IntlCalendar $calendar): int|false\nGet minimal number of days the first week in a year or month can have',
	'IntlCalendar::getMinimum': '(int $field): int|false\nGet the global minimum value for a field',
	'intlcal_get_minimum': '(IntlCalendar $calendar, int $field): int|false\nGet the global minimum value for a field',
	'IntlCalendar::getNow': '(): float\nGet number representing the current time',
	'intlcal_get_now': '(): float\nGet number representing the current time',
	'IntlCalendar::getRepeatedWallTimeOption': '(): int\nGet behavior for handling repeating wall time',
	'intlcal_get_repeated_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling repeating wall time',
	'IntlCalendar::getSkippedWallTimeOption': '(): int\nGet behavior for handling skipped wall time',
	'intlcal_get_skipped_wall_time_option': '(IntlCalendar $calendar): int\nGet behavior for handling skipped wall time',
	'IntlCalendar::getTime': '(): float|false\nGet time currently represented by the object',
	'intlcal_get_time': '(IntlCalendar $calendar): float|false\nGet time currently represented by the object',
	'IntlCalendar::getTimeZone': '(): IntlTimeZone|false\nGet the objectʼs timezone',
	'intlcal_get_time_zone': '(IntlCalendar $calendar): IntlTimeZone|false\nGet the objectʼs timezone',
	'IntlCalendar::getType': '(): string\nGet the calendar type',
	'intlcal_get_type': '(IntlCalendar $calendar): string\nGet the calendar type',
	'IntlCalendar::getWeekendTransition': '(int $dayOfWeek): int|false\nGet time of the day at which weekend begins or ends',
	'intlcal_get_weekend_transition': '(IntlCalendar $calendar, int $dayOfWeek): int|false\nGet time of the day at which weekend begins or ends',
	'IntlCalendar::inDaylightTime': '(): bool\nWhether the objectʼs time is in Daylight Savings Time',
	'intlcal_in_daylight_time': '(IntlCalendar $calendar): bool\nWhether the objectʼs time is in Daylight Savings Time',
	'IntlCalendar::isEquivalentTo': '(IntlCalendar $other): bool\nWhether another calendar is equal but for a different time',
	'intlcal_is_equivalent_to': '(IntlCalendar $calendar, IntlCalendar $other): bool\nWhether another calendar is equal but for a different time',
	'IntlCalendar::isLenient': '(): bool\nWhether date/time interpretation is in lenient mode',
	'intlcal_is_lenient': '(IntlCalendar $calendar): bool\nWhether date/time interpretation is in lenient mode',
	'IntlCalendar::isSet': '(int $field): bool\nWhether a field is set',
	'intlcal_is_set': '(IntlCalendar $calendar, int $field): bool\nWhether a field is set',
	'IntlCalendar::isWeekend': '(float|null $timestamp = null): bool\nWhether a certain date/time is in the weekend',
	'intlcal_is_weekend': '(IntlCalendar $calendar, float|null $timestamp = null): bool\nWhether a certain date/time is in the weekend',
	'IntlCalendar::roll': '(int $field, int|bool $value): bool\nAdd value to field without carrying into more significant fields',
	'intlcal_roll': '(IntlCalendar $calendar, int $field, int|bool $value): bool\nAdd value to field without carrying into more significant fields',
	'IntlCalendar::set': '(int $field, int $value): true\nSet a time field or several common fields at once',
	'IntlCalendar::set': '(int $year, int $month, int $dayOfMonth = NULL, int $hour = NULL, int $minute = NULL, int $second = NULL): true\nSet a time field or several common fields at once',
	'intlcal_set': '(IntlCalendar $cal, int $field, int $value): true\nSet a time field or several common fields at once',
	'intlcal_set': '(IntlCalendar $cal, int $year, int $month, int $dayOfMonth = NULL, int $hour = NULL, int $minute = NULL, int $second = NULL): bool\nSet a time field or several common fields at once',
	'IntlCalendar::setDate': '(int $year, int $month, int $dayOfMonth): void\nSet a date fields',
	'IntlCalendar::setDateTime': '(int $year, int $month, int $dayOfMonth, int $hour, int $minute, int|null $second = null): void\nSet a date and time fields',
	'IntlCalendar::setFirstDayOfWeek': '(int $dayOfWeek): true\nSet the day on which the week is deemed to start',
	'intlcal_set_first_day_of_week': '(IntlCalendar $calendar, int $dayOfWeek): true\nSet the day on which the week is deemed to start',
	'IntlCalendar::setLenient': '(bool $lenient): true\nSet whether date/time interpretation is to be lenient',
	'intlcal_set_lenient': '(IntlCalendar $calendar, bool $lenient): true\nSet whether date/time interpretation is to be lenient',
	'IntlCalendar::setMinimalDaysInFirstWeek': '(int $days): true\nSet minimal number of days the first week in a year or month can have',
	'intlcal_set_minimal_days_in_first_week': '(IntlCalendar $calendar, int $days): true\nSet minimal number of days the first week in a year or month can have',
	'IntlCalendar::setRepeatedWallTimeOption': '(int $option): true\nSet behavior for handling repeating wall times at negative timezone offset transitions',
	'intlcal_set_repeated_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling repeating wall times at negative timezone offset transitions',
	'IntlCalendar::setSkippedWallTimeOption': '(int $option): true\nSet behavior for handling skipped wall times at positive timezone offset transitions',
	'intlcal_set_skipped_wall_time_option': '(IntlCalendar $calendar, int $option): true\nSet behavior for handling skipped wall times at positive timezone offset transitions',
	'IntlCalendar::setTime': '(float $timestamp): bool\nSet the calendar time in milliseconds since the epoch',
	'intlcal_set_time': '(IntlCalendar $calendar, float $timestamp): bool\nSet the calendar time in milliseconds since the epoch',
	'IntlCalendar::setTimeZone': '(IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSet the timezone used by this calendar',
	'intlcal_set_time_zone': '(IntlCalendar $calendar, IntlTimeZone|DateTimeZone|string|null $timezone): bool\nSet the timezone used by this calendar',
	'IntlCalendar::toDateTime': '(): DateTime|false\nConvert an IntlCalendar into a DateTime object',
	'intlcal_to_date_time': '(IntlCalendar $calendar): DateTime|false\nConvert an IntlCalendar into a DateTime object',
	'IntlChar::charAge': '(int|string $codepoint): array|null\nGet the "age" of the code point',
	'IntlChar::charDigitValue': '(int|string $codepoint): int|null\nGet the decimal digit value of a decimal digit character',
	'IntlChar::charDirection': '(int|string $codepoint): int|null\nGet bidirectional category value for a code point',
	'IntlChar::charFromName': '(string $name, int $type = IntlChar::UNICODE_CHAR_NAME): int|null\nFind Unicode character by name and return its code point value',
	'IntlChar::charMirror': '(int|string $codepoint): int|string|null\nGet the "mirror-image" character for a code point',
	'IntlChar::charName': '(int|string $codepoint, int $type = IntlChar::UNICODE_CHAR_NAME): string|null\nRetrieve the name of a Unicode character',
	'IntlChar::charType': '(int|string $codepoint): int|null\nGet the general category value for a code point',
	'IntlChar::chr': '(int|string $codepoint): string|null\nReturn Unicode character by code point value',
	'IntlChar::digit': '(int|string $codepoint, int $base = 10): int|false|null\nGet the decimal digit value of a code point for a given radix',
	'IntlChar::enumCharNames': '(int|string $start, int|string $end, callable $callback, int $type = IntlChar::UNICODE_CHAR_NAME): bool\nEnumerate all assigned Unicode characters within a range',
	'IntlChar::enumCharTypes': '(callable $callback): void\nEnumerate all code points with their Unicode general categories',
	'IntlChar::foldCase': '(int|string $codepoint, int $options = IntlChar::FOLD_CASE_DEFAULT): int|string|null\nPerform case folding on a code point',
	'IntlChar::forDigit': '(int $digit, int $base = 10): int\nGet character representation for a given digit and radix',
	'IntlChar::getBidiPairedBracket': '(int|string $codepoint): int|string|null\nGet the paired bracket character for a code point',
	'IntlChar::getBlockCode': '(int|string $codepoint): int|null\nGet the Unicode allocation block containing a code point',
	'IntlChar::getCombiningClass': '(int|string $codepoint): int|null\nGet the combining class of a code point',
	'IntlChar::getFC_NFKC_Closure': '(int|string $codepoint): string|false|null\nGet the FC_NFKC_Closure property for a code point',
	'IntlChar::getIntPropertyMaxValue': '(int $property): int\nGet the max value for a Unicode property',
	'IntlChar::getIntPropertyMinValue': '(int $property): int\nGet the min value for a Unicode property',
	'IntlChar::getIntPropertyValue': '(int|string $codepoint, int $property): int|null\nGet the value for a Unicode property for a code point',
	'IntlChar::getNumericValue': '(int|string $codepoint): float|null\nGet the numeric value for a Unicode code point',
	'IntlChar::getPropertyEnum': '(string $alias): int\nGet the property constant value for a given property name',
	'IntlChar::getPropertyName': '(int $property, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property',
	'IntlChar::getPropertyValueEnum': '(int $property, string $name): int\nGet the property value for a given value name',
	'IntlChar::getPropertyValueName': '(int $property, int $value, int $type = IntlChar::LONG_PROPERTY_NAME): string|false\nGet the Unicode name for a property value',
	'IntlChar::getUnicodeVersion': '(): array\nGet the Unicode version',
	'IntlChar::hasBinaryProperty': '(int|string $codepoint, int $property): bool|null\nCheck a binary Unicode property for a code point',
	'IntlChar::isalnum': '(int|string $codepoint): bool|null\nCheck if code point is an alphanumeric character',
	'IntlChar::isalpha': '(int|string $codepoint): bool|null\nCheck if code point is a letter character',
	'IntlChar::isbase': '(int|string $codepoint): bool|null\nCheck if code point is a base character',
	'IntlChar::isblank': '(int|string $codepoint): bool|null\nCheck if code point is a "blank" or "horizontal space" character',
	'IntlChar::iscntrl': '(int|string $codepoint): bool|null\nCheck if code point is a control character',
	'IntlChar::isdefined': '(int|string $codepoint): bool|null\nCheck whether the code point is defined',
	'IntlChar::isdigit': '(int|string $codepoint): bool|null\nCheck if code point is a digit character',
	'IntlChar::isgraph': '(int|string $codepoint): bool|null\nCheck if code point is a graphic character',
	'IntlChar::isIDIgnorable': '(int|string $codepoint): bool|null\nCheck if code point is an ignorable character',
	'IntlChar::isIDPart': '(int|string $codepoint): bool|null\nCheck if code point is permissible in an identifier',
	'IntlChar::isIDStart': '(int|string $codepoint): bool|null\nCheck if code point is permissible as the first character in an identifier',
	'IntlChar::isISOControl': '(int|string $codepoint): bool|null\nCheck if code point is an ISO control code',
	'IntlChar::isJavaIDPart': '(int|string $codepoint): bool|null\nCheck if code point is permissible in a Java identifier',
	'IntlChar::isJavaIDStart': '(int|string $codepoint): bool|null\nCheck if code point is permissible as the first character in a Java identifier',
	'IntlChar::isJavaSpaceChar': '(int|string $codepoint): bool|null\nCheck if code point is a space character according to Java',
	'IntlChar::islower': '(int|string $codepoint): bool|null\nCheck if code point is a lowercase letter',
	'IntlChar::isMirrored': '(int|string $codepoint): bool|null\nCheck if code point has the Bidi_Mirrored property',
	'IntlChar::isprint': '(int|string $codepoint): bool|null\nCheck if code point is a printable character',
	'IntlChar::ispunct': '(int|string $codepoint): bool|null\nCheck if code point is punctuation character',
	'IntlChar::isspace': '(int|string $codepoint): bool|null\nCheck if code point is a space character',
	'IntlChar::istitle': '(int|string $codepoint): bool|null\nCheck if code point is a titlecase letter',
	'IntlChar::isUAlphabetic': '(int|string $codepoint): bool|null\nCheck if code point has the Alphabetic Unicode property',
	'IntlChar::isULowercase': '(int|string $codepoint): bool|null\nCheck if code point has the Lowercase Unicode property',
	'IntlChar::isupper': '(int|string $codepoint): bool|null\nCheck if code point has the general category "Lu" (uppercase letter)',
	'IntlChar::isUUppercase': '(int|string $codepoint): bool|null\nCheck if code point has the Uppercase Unicode property',
	'IntlChar::isUWhiteSpace': '(int|string $codepoint): bool|null\nCheck if code point has the White_Space Unicode property',
	'IntlChar::isWhitespace': '(int|string $codepoint): bool|null\nCheck if code point is a whitespace character according to ICU',
	'IntlChar::isxdigit': '(int|string $codepoint): bool|null\nCheck if code point is a hexadecimal digit',
	'IntlChar::ord': '(int|string $character): int|null\nReturn Unicode code point value of character',
	'IntlChar::tolower': '(int|string $codepoint): int|string|null\nMake Unicode character lowercase',
	'IntlChar::totitle': '(int|string $codepoint): int|string|null\nMake Unicode character titlecase',
	'IntlChar::toupper': '(int|string $codepoint): int|string|null\nMake Unicode character uppercase',
	'IntlCodePointBreakIterator::getLastCodePoint': '(): int\nGet last code point passed over after advancing or receding the iterator',
	'IntlDatePatternGenerator::create': '(string|null $locale = null): IntlDatePatternGenerator|null\nCreates a new IntlDatePatternGenerator instance',
	'IntlDatePatternGenerator::getBestPattern': '(string $skeleton): string|false\nDetermines the most suitable date/time format',
	'IntlGregorianCalendar::createFromDate': '(int $year, int $month, int $dayOfMonth): static\nCreate a new IntlGregorianCalendar instance from date',
	'IntlGregorianCalendar::createFromDateTime': '(int $year, int $month, int $dayOfMonth, int $hour, int $minute, int|null $second = null): static\nCreate a new IntlGregorianCalendar instance from date and time',
	'IntlGregorianCalendar::getGregorianChange': '(): float\nGet the Gregorian Calendar change date',
	'IntlGregorianCalendar::isLeapYear': '(int $year): bool\nDetermine if the given year is a leap year',
	'IntlGregorianCalendar::setGregorianChange': '(float $timestamp): bool\nSet the Gregorian Calendar the change date',
	'IntlIterator::current': '(): mixed\nGet the current element',
	'IntlIterator::key': '(): mixed\nGet the current key',
	'IntlIterator::next': '(): void\nMove forward to the next element',
	'IntlIterator::rewind': '(): void\nRewind the iterator to the first element',
	'IntlIterator::valid': '(): bool\nCheck if current position is valid',
	'IntlPartsIterator::getBreakIterator': '(): IntlBreakIterator\nGet IntlBreakIterator backing this parts iterator',
	'IntlRuleBasedBreakIterator::getBinaryRules': '(): string|false\nGet the binary form of compiled rules',
	'IntlRuleBasedBreakIterator::getRules': '(): string|false\nGet the rule set used to create this object',
	'IntlRuleBasedBreakIterator::getRuleStatus': '(): int\nGet the largest status value from the break rules that determined the current break position',
	'IntlRuleBasedBreakIterator::getRuleStatusVec': '(): array|false\nGet the status values from the break rules that determined the current break position',
	'IntlTimeZone::countEquivalentIDs': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
	'intltz_count_equivalent_ids': '(string $timezoneId): int|false\nGet the number of IDs in the equivalency group that includes the given ID',
	'IntlTimeZone::createDefault': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
	'intltz_create_default': '(): IntlTimeZone\nCreate a new copy of the default timezone for this host',
	'IntlTimeZone::createEnumeration': '(IntlTimeZone|string|int|float|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
	'intltz_create_enumeration': '(IntlTimeZone|string|int|float|null $countryOrRawOffset = null): IntlIterator|false\nGet an enumeration over time zone IDs associated with the given country or offset',
	'IntlTimeZone::createTimeZone': '(string $timezoneId): IntlTimeZone|null\nCreate a timezone object for the given ID',
	'intltz_create_time_zone': '(string $timezoneId): IntlTimeZone|null\nCreate a timezone object for the given ID',
	'IntlTimeZone::createTimeZoneIDEnumeration': '(int $type, string|null $region = null, int|null $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
	'intltz_create_time_zone_id_enumeration': '(int $type, string|null $region = null, int|null $rawOffset = null): IntlIterator|false\nGet an enumeration over system time zone IDs with the given filter conditions',
	'IntlTimeZone::fromDateTimeZone': '(DateTimeZone $timezone): IntlTimeZone|null\nCreate a timezone object from DateTimeZone',
	'intltz_from_date_time_zone': '(DateTimeZone $timezone): IntlTimeZone|null\nCreate a timezone object from DateTimeZone',
	'IntlTimeZone::getCanonicalID': '(string $timezoneId, bool $isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
	'intltz_get_canonical_id': '(string $timezoneId, bool $isSystemId = null): string|false\nGet the canonical system timezone ID or the normalized custom time zone ID for the given time zone ID',
	'IntlTimeZone::getDisplayName': '(bool $dst = false, int $style = IntlTimeZone::DISPLAY_LONG, string|null $locale = null): string|false\nGet a name of this time zone suitable for presentation to the user',
	'intltz_get_display_name': '(IntlTimeZone $timezone, bool $dst = false, int $style = IntlTimeZone::DISPLAY_LONG, string|null $locale = null): string|false\nGet a name of this time zone suitable for presentation to the user',
	'IntlTimeZone::getDSTSavings': '(): int\nGet the amount of time to be added to local standard time to get local wall clock time',
	'intltz_get_dst_savings': '(IntlTimeZone $timezone): int\nGet the amount of time to be added to local standard time to get local wall clock time',
	'IntlTimeZone::getEquivalentID': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
	'intltz_get_equivalent_id': '(string $timezoneId, int $offset): string|false\nGet an ID in the equivalency group that includes the given ID',
	'IntlTimeZone::getErrorCode': '(): int|false\nGet last error code on the object',
	'intltz_get_error_code': '(IntlTimeZone $timezone): int|false\nGet last error code on the object',
	'IntlTimeZone::getErrorMessage': '(): string|false\nGet last error message on the object',
	'intltz_get_error_message': '(IntlTimeZone $timezone): string|false\nGet last error message on the object',
	'IntlTimeZone::getGMT': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
	'intltz_get_gmt': '(): IntlTimeZone\nCreate GMT (UTC) timezone',
	'IntlTimeZone::getID': '(): string|false\nGet timezone ID',
	'intltz_get_id': '(IntlTimeZone $timezone): string|false\nGet timezone ID',
	'IntlTimeZone::getIDForWindowsID': '(string $timezoneId, string|null $region = null): string|false\nTranslate a Windows timezone into a system timezone',
	'intltz_get_id_for_windows_id': '(string $timezoneId, string|null $region = null): string|false\nTranslate a Windows timezone into a system timezone',
	'IntlTimeZone::getOffset': '(float $timestamp, bool $local, int $rawOffset, int $dstOffset): bool\nGet the time zone raw and GMT offset for the given moment in time',
	'intltz_get_offset': '(IntlTimeZone $timezone, float $timestamp, bool $local, int $rawOffset, int $dstOffset): bool\nGet the time zone raw and GMT offset for the given moment in time',
	'IntlTimeZone::getRawOffset': '(): int\nGet the raw GMT offset (before taking daylight savings time into account',
	'intltz_get_raw_offset': '(IntlTimeZone $timezone): int\nGet the raw GMT offset (before taking daylight savings time into account',
	'IntlTimeZone::getRegion': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
	'intltz_get_region': '(string $timezoneId): string|false\nGet the region code associated with the given system time zone ID',
	'IntlTimeZone::getTZDataVersion': '(): string|false\nGet the timezone data version currently used by ICU',
	'intltz_get_tz_data_version': '(): string|false\nGet the timezone data version currently used by ICU',
	'IntlTimeZone::getUnknown': '(): IntlTimeZone\nGet the "unknown" time zone',
	'intltz_get_unknown': '(): IntlTimeZone\nGet the "unknown" time zone',
	'IntlTimeZone::getWindowsID': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
	'intltz_get_windows_id': '(string $timezoneId): string|false\nTranslate a system timezone into a Windows timezone',
	'IntlTimeZone::hasSameRules': '(IntlTimeZone $other): bool\nCheck if this zone has the same rules and offset as another zone',
	'intltz_has_same_rules': '(IntlTimeZone $timezone, IntlTimeZone $other): bool\nCheck if this zone has the same rules and offset as another zone',
	'IntlTimeZone::toDateTimeZone': '(): DateTimeZone|false\nConvert to DateTimeZone object',
	'intltz_to_date_time_zone': '(IntlTimeZone $timezone): DateTimeZone|false\nConvert to DateTimeZone object',
	'IntlTimeZone::useDaylightTime': '(): bool\nCheck if this time zone uses daylight savings time',
	'intltz_use_daylight_time': '(IntlTimeZone $timezone): bool\nCheck if this time zone uses daylight savings time',
	'Locale::acceptFromHttp': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
	'locale_accept_from_http': '(string $header): string|false\nTries to find out best available locale based on HTTP "Accept-Language" header',
	'Locale::canonicalize': '(string $locale): string|null\nCanonicalize the locale string',
	'Locale::composeLocale': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
	'locale_compose': '(array $subtags): string|false\nReturns a correctly ordered and delimited locale ID',
	'Locale::filterMatches': '(string $languageTag, string $locale, bool $canonicalize = false): bool|null\nChecks if a language tag filter matches with locale',
	'locale_filter_matches': '(string $languageTag, string $locale, bool $canonicalize = false): bool|null\nChecks if a language tag filter matches with locale',
	'Locale::getAllVariants': '(string $locale): array|null\nGets the variants for the input locale',
	'locale_get_all_variants': '(string $locale): array|null\nGets the variants for the input locale',
	'Locale::getDefault': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
	'locale_get_default': '(): string\nGets the default locale value from the INTL global \'default_locale\'',
	'Locale::getDisplayLanguage': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
	'locale_get_display_language': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for language of the inputlocale',
	'Locale::getDisplayName': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
	'locale_get_display_name': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for the input locale',
	'Locale::getDisplayRegion': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
	'locale_get_display_region': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for region of the input locale',
	'Locale::getDisplayScript': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
	'locale_get_display_script': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for script of the input locale',
	'Locale::getDisplayVariant': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
	'locale_get_display_variant': '(string $locale, string|null $displayLocale = null): string|false\nReturns an appropriately localized display name for variants of the input locale',
	'Locale::getKeywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
	'locale_get_keywords': '(string $locale): array|false|null\nGets the keywords for the input locale',
	'Locale::getPrimaryLanguage': '(string $locale): string|null\nGets the primary language for the input locale',
	'locale_get_primary_language': '(string $locale): string|null\nGets the primary language for the input locale',
	'Locale::getRegion': '(string $locale): string|null\nGets the region for the input locale',
	'locale_get_region': '(string $locale): string|null\nGets the region for the input locale',
	'Locale::getScript': '(string $locale): string|null\nGets the script for the input locale',
	'locale_get_script': '(string $locale): string|null\nGets the script for the input locale',
	'Locale::lookup': '(array $languageTag, string $locale, bool $canonicalize = false, string|null $defaultLocale = null): string|null\nSearches the language tag list for the best match to the language',
	'locale_lookup': '(array $languageTag, string $locale, bool $canonicalize = false, string|null $defaultLocale = null): string|null\nSearches the language tag list for the best match to the language',
	'Locale::parseLocale': '(string $locale): array|null\nReturns a key-value array of locale ID subtag elements',
	'locale_parse': '(string $locale): array|null\nReturns a key-value array of locale ID subtag elements',
	'Locale::setDefault': '(string $locale): true\nSets the default runtime locale',
	'locale_set_default': '(string $locale): true\nSets the default runtime locale',
	'MessageFormatter::create': '(string $locale, string $pattern): MessageFormatter|null\nConstructs a new Message Formatter',
	'msgfmt_create': '(string $locale, string $pattern): MessageFormatter|null\nConstructs a new Message Formatter',
	'MessageFormatter::formatMessage': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
	'msgfmt_format_message': '(string $locale, string $pattern, array $values): string|false\nQuick format message',
	'MessageFormatter::format': '(array $values): string|false\nFormat the message',
	'msgfmt_format': '(MessageFormatter $formatter, array $values): string|false\nFormat the message',
	'MessageFormatter::getErrorCode': '(): int\nGet the error code from last operation',
	'msgfmt_get_error_code': '(MessageFormatter $formatter): int\nGet the error code from last operation',
	'MessageFormatter::getErrorMessage': '(): string\nGet the error text from the last operation',
	'msgfmt_get_error_message': '(MessageFormatter $formatter): string\nGet the error text from the last operation',
	'MessageFormatter::getLocale': '(): string\nGet the locale for which the formatter was created',
	'msgfmt_get_locale': '(MessageFormatter $formatter): string\nGet the locale for which the formatter was created',
	'MessageFormatter::getPattern': '(): string|false\nGet the pattern used by the formatter',
	'msgfmt_get_pattern': '(MessageFormatter $formatter): string|false\nGet the pattern used by the formatter',
	'MessageFormatter::parseMessage': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
	'msgfmt_parse_message': '(string $locale, string $pattern, string $message): array|false\nQuick parse input string',
	'MessageFormatter::parse': '(string $string): array|false\nParse input string according to pattern',
	'msgfmt_parse': '(MessageFormatter $formatter, string $string): array|false\nParse input string according to pattern',
	'MessageFormatter::setPattern': '(string $pattern): bool\nSet the pattern used by the formatter',
	'msgfmt_set_pattern': '(MessageFormatter $formatter, string $pattern): bool\nSet the pattern used by the formatter',
	'Normalizer::getRawDecomposition': '(string $string, int $form = Normalizer::FORM_C): string|null\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
	'normalizer_get_raw_decomposition': '(string $string, int $form = Normalizer::FORM_C): string|null\nGets the Decomposition_Mapping property for the given UTF-8 encoded code point',
	'Normalizer::isNormalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
	'normalizer_is_normalized': '(string $string, int $form = Normalizer::FORM_C): bool\nChecks if the provided string is already in the specified normalization form',
	'Normalizer::normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
	'normalizer_normalize': '(string $string, int $form = Normalizer::FORM_C): string|false\nNormalizes the input provided and returns the normalized string',
	'NumberFormatter::create': '(string $locale, int $style, string|null $pattern = null): NumberFormatter|null\nCreate a number formatter',
	'numfmt_create': '(string $locale, int $style, string|null $pattern = null): NumberFormatter|null\nCreate a number formatter',
	'NumberFormatter::formatCurrency': '(float $amount, string $currency): string|false\nFormat a currency value',
	'numfmt_format_currency': '(NumberFormatter $formatter, float $amount, string $currency): string|false\nFormat a currency value',
	'NumberFormatter::format': '(int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false\nFormat a number',
	'numfmt_format': '(NumberFormatter $formatter, int|float $num, int $type = NumberFormatter::TYPE_DEFAULT): string|false\nFormat a number',
	'NumberFormatter::getAttribute': '(int $attribute): int|float|false\nGet an attribute',
	'numfmt_get_attribute': '(NumberFormatter $formatter, int $attribute): int|float|false\nGet an attribute',
	'NumberFormatter::getErrorCode': '(): int\nGet formatter\'s last error code',
	'numfmt_get_error_code': '(NumberFormatter $formatter): int\nGet formatter\'s last error code',
	'NumberFormatter::getErrorMessage': '(): string\nGet formatter\'s last error message',
	'numfmt_get_error_message': '(NumberFormatter $formatter): string\nGet formatter\'s last error message',
	'NumberFormatter::getLocale': '(int $type = ULOC_ACTUAL_LOCALE): string|false\nGet formatter locale',
	'numfmt_get_locale': '(NumberFormatter $formatter, int $type = ULOC_ACTUAL_LOCALE): string|false\nGet formatter locale',
	'NumberFormatter::getPattern': '(): string|false\nGet formatter pattern',
	'numfmt_get_pattern': '(NumberFormatter $formatter): string|false\nGet formatter pattern',
	'NumberFormatter::getSymbol': '(int $symbol): string|false\nGet a symbol value',
	'numfmt_get_symbol': '(NumberFormatter $formatter, int $symbol): string|false\nGet a symbol value',
	'NumberFormatter::getTextAttribute': '(int $attribute): string|false\nGet a text attribute',
	'numfmt_get_text_attribute': '(NumberFormatter $formatter, int $attribute): string|false\nGet a text attribute',
	'NumberFormatter::parseCurrency': '(string $string, string $currency, int $offset = null): float|false\nParse a currency number',
	'numfmt_parse_currency': '(NumberFormatter $formatter, string $string, string $currency, int $offset = null): float|false\nParse a currency number',
	'NumberFormatter::parse': '(string $string, int $type = NumberFormatter::TYPE_DOUBLE, int $offset = null): int|float|false\nParse a number',
	'numfmt_parse': '(NumberFormatter $formatter, string $string, int $type = NumberFormatter::TYPE_DOUBLE, int $offset = null): int|float|false\nParse a number',
	'NumberFormatter::setAttribute': '(int $attribute, int|float $value): bool\nSet an attribute',
	'numfmt_set_attribute': '(NumberFormatter $formatter, int $attribute, int|float $value): bool\nSet an attribute',
	'NumberFormatter::setPattern': '(string $pattern): bool\nSet formatter pattern',
	'numfmt_set_pattern': '(NumberFormatter $formatter, string $pattern): bool\nSet formatter pattern',
	'NumberFormatter::setSymbol': '(int $symbol, string $value): bool\nSet a symbol value',
	'numfmt_set_symbol': '(NumberFormatter $formatter, int $symbol, string $value): bool\nSet a symbol value',
	'NumberFormatter::setTextAttribute': '(int $attribute, string $value): bool\nSet a text attribute',
	'numfmt_set_text_attribute': '(NumberFormatter $formatter, int $attribute, string $value): bool\nSet a text attribute',
	'ResourceBundle::count': '(): int\nGet number of elements in the bundle',
	'resourcebundle_count': '(ResourceBundle $bundle): int\nGet number of elements in the bundle',
	'ResourceBundle::create': '(string|null $locale, string|null $bundle, bool $fallback = true): ResourceBundle|null\nCreate a resource bundle',
	'resourcebundle_create': '(string|null $locale, string|null $bundle, bool $fallback = true): ResourceBundle|null\nCreate a resource bundle',
	'ResourceBundle::getErrorCode': '(): int\nGet bundle\'s last error code',
	'resourcebundle_get_error_code': '(ResourceBundle $bundle): int\nGet bundle\'s last error code',
	'ResourceBundle::getErrorMessage': '(): string\nGet bundle\'s last error message',
	'resourcebundle_get_error_message': '(ResourceBundle $bundle): string\nGet bundle\'s last error message',
	'ResourceBundle::get': '(string|int $index, bool $fallback = true): mixed\nGet data from the bundle',
	'resourcebundle_get': '(ResourceBundle $bundle, string|int $index, bool $fallback = true): mixed\nGet data from the bundle',
	'ResourceBundle::getLocales': '(string $bundle): array|false\nGet supported locales',
	'resourcebundle_locales': '(string $bundle): array|false\nGet supported locales',
	'Spoofchecker::areConfusable': '(string $string1, string $string2, int $errorCode = null): bool\nChecks if given strings can be confused',
	'Spoofchecker::isSuspicious': '(string $string, int $errorCode = null): bool\nChecks if a given text contains any suspicious characters',
	'Spoofchecker::setAllowedLocales': '(string $locales): void\nLocales to use when running checks',
	'Spoofchecker::setChecks': '(int $checks): void\nSet the checks to run',
	'Spoofchecker::setRestrictionLevel': '(int $level): void\nSet the restriction level',
	'Transliterator::create': '(string $id, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate a transliterator',
	'transliterator_create': '(string $id, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate a transliterator',
	'Transliterator::createFromRules': '(string $rules, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate transliterator from rules',
	'transliterator_create_from_rules': '(string $rules, int $direction = Transliterator::FORWARD): Transliterator|null\nCreate transliterator from rules',
	'Transliterator::createInverse': '(): Transliterator|null\nCreate an inverse transliterator',
	'transliterator_create_inverse': '(Transliterator $transliterator): Transliterator|null\nCreate an inverse transliterator',
	'Transliterator::getErrorCode': '(): int|false\nGet last error code',
	'transliterator_get_error_code': '(Transliterator $transliterator): int|false\nGet last error code',
	'Transliterator::getErrorMessage': '(): string|false\nGet last error message',
	'transliterator_get_error_message': '(Transliterator $transliterator): string|false\nGet last error message',
	'Transliterator::listIDs': '(): array|false\nGet transliterator IDs',
	'transliterator_list_ids': '(): array|false\nGet transliterator IDs',
	'Transliterator::transliterate': '(string $string, int $start = ?, int $end = -1): string|false\nTransliterate a string',
	'transliterator_transliterate': '(Transliterator|string $transliterator, string $string, int $start = ?, int $end = -1): string|false\nTransliterate a string',
	'UConverter::convert': '(string $str, bool $reverse = false): string|false\nConvert string from one charset to another',
	'UConverter::fromUCallback': '(int $reason, array $source, int $codePoint, int $error): string|int|array|null\nDefault "from" callback function',
	'UConverter::getAliases': '(string $name): array|false|null\nGet the aliases of the given name',
	'UConverter::getAvailable': '(): array\nGet the available canonical converter names',
	'UConverter::getDestinationEncoding': '(): string|false|null\nGet the destination encoding',
	'UConverter::getDestinationType': '(): int|false|null\nGet the destination converter type',
	'UConverter::getErrorCode': '(): int\nGet last error code on the object',
	'UConverter::getErrorMessage': '(): string|null\nGet last error message on the object',
	'UConverter::getSourceEncoding': '(): string|false|null\nGet the source encoding',
	'UConverter::getSourceType': '(): int|false|null\nGet the source converter type',
	'UConverter::getStandards': '(): array|null\nGet standards associated to converter names',
	'UConverter::getSubstChars': '(): string|false|null\nGet substitution chars',
	'UConverter::reasonText': '(int $reason): string\nGet string representation of the callback reason',
	'UConverter::setDestinationEncoding': '(string $encoding): bool\nSet the destination encoding',
	'UConverter::setSourceEncoding': '(string $encoding): bool\nSet the source encoding',
	'UConverter::setSubstChars': '(string $chars): bool\nSet the substitution chars',
	'UConverter::toUCallback': '(int $reason, string $source, string $codeUnits, int $error): string|int|array|null\nDefault "to" callback function',
	'UConverter::transcode': '(string $str, string $toEncoding, string $fromEncoding, array|null $options = null): string|false\nConvert a string from one character encoding to another',
	'mb_check_encoding': '(array|string|null $value = null, string|null $encoding = null): bool\nCheck if strings are valid for the specified encoding',
	'mb_chr': '(int $codepoint, string|null $encoding = null): string|false\nReturn character by Unicode code point value',
	'mb_convert_case': '(string $string, int $mode, string|null $encoding = null): string\nPerform case folding on a string',
	'mb_convert_encoding': '(array|string $string, string $to_encoding, array|string|null $from_encoding = null): array|string|false\nConvert a string from one character encoding to another',
	'mb_convert_kana': '(string $string, string $mode = "KV", string|null $encoding = null): string\nConvert "kana" one from another ("zen-kaku", "han-kaku" and more)',
	'mb_convert_variables': '(string $to_encoding, array|string $from_encoding, mixed $var, mixed ...$vars): string|false\nConvert character code in variable(s)',
	'mb_decode_mimeheader': '(string $string): string\nDecode string in MIME header field',
	'mb_decode_numericentity': '(string $string, array $map, string|null $encoding = null): string\nDecode HTML numeric string reference to character',
	'mb_detect_encoding': '(string $string, array|string|null $encodings = null, bool $strict = false): string|false\nDetect character encoding',
	'mb_detect_order': '(array|string|null $encoding = null): array|bool\nSet/Get character encoding detection order',
	'mb_encode_mimeheader': '(string $string, string|null $charset = null, string|null $transfer_encoding = null, string $newline = "\\r\\n", int $indent = ?): string\nEncode string for MIME header',
	'mb_encode_numericentity': '(string $string, array $map, string|null $encoding = null, bool $hex = false): string\nEncode character to HTML numeric string reference',
	'mb_encoding_aliases': '(string $encoding): array\nGet aliases of a known encoding type',
	'mb_ereg_match': '(string $pattern, string $string, string|null $options = null): bool\nRegular expression match for multibyte string',
	'mb_ereg_replace_callback': '(string $pattern, callable $callback, string $string, string|null $options = null): string|false|null\nPerform a regular expression search and replace with multibyte support using a callback',
	'mb_ereg_replace': '(string $pattern, string $replacement, string $string, string|null $options = null): string|false|null\nReplace regular expression with multibyte support',
	'mb_ereg_search_getpos': '(): int\nReturns start point for next regular expression match',
	'mb_ereg_search_getregs': '(): array|false\nRetrieve the result from the last multibyte regular expression match',
	'mb_ereg_search_init': '(string $string, string|null $pattern = null, string|null $options = null): bool\nSetup string and regular expression for a multibyte regular expression match',
	'mb_ereg_search_pos': '(string|null $pattern = null, string|null $options = null): array|false\nReturns position and length of a matched part of the multibyte regular expression for a predefined multibyte string',
	'mb_ereg_search_regs': '(string|null $pattern = null, string|null $options = null): array|false\nReturns the matched part of a multibyte regular expression',
	'mb_ereg_search_setpos': '(int $offset): bool\nSet start point of next regular expression match',
	'mb_ereg_search': '(string|null $pattern = null, string|null $options = null): bool\nMultibyte regular expression match for predefined multibyte string',
	'mb_ereg': '(string $pattern, string $string, array $matches = null): bool\nRegular expression match with multibyte support',
	'mb_eregi_replace': '(string $pattern, string $replacement, string $string, string|null $options = null): string|false|null\nReplace regular expression with multibyte support ignoring case',
	'mb_eregi': '(string $pattern, string $string, array $matches = null): bool\nRegular expression match ignoring case with multibyte support',
	'mb_get_info': '(string $type = "all"): array|string|int|false|null\nGet internal settings of mbstring',
	'mb_http_input': '(string|null $type = null): array|string|false\nDetect HTTP input character encoding',
	'mb_http_output': '(string|null $encoding = null): string|bool\nSet/Get HTTP output character encoding',
	'mb_internal_encoding': '(string|null $encoding = null): string|bool\nSet/Get internal character encoding',
	'mb_language': '(string|null $language = null): string|bool\nSet/Get current language',
	'mb_lcfirst': '(string $string, string|null $encoding = null): string\nMake a string\'s first character lowercase',
	'mb_list_encodings': '(): array\nReturns an array of all supported encodings',
	'mb_ltrim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the beginning of a string',
	'mb_ord': '(string $string, string|null $encoding = null): int|false\nGet Unicode code point of character',
	'mb_output_handler': '(string $string, int $status): string\nCallback function converts character encoding in output buffer',
	'mb_parse_str': '(string $string, array $result): bool\nParse GET/POST/COOKIE data and set global variable',
	'mb_preferred_mime_name': '(string $encoding): string|false\nGet MIME charset string',
	'mb_regex_encoding': '(string|null $encoding = null): string|bool\nSet/Get character encoding for multibyte regex',
	'mb_regex_set_options': '(string|null $options = null): string\nSet/Get the default options for mbregex functions',
	'mb_rtrim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the end of a string',
	'mb_scrub': '(string $string, string|null $encoding = null): string\nReplace ill-formed byte sequences with the substitute character',
	'mb_send_mail': '(string $to, string $subject, string $message, array|string $additional_headers = [], string|null $additional_params = null): bool\nSend encoded mail',
	'mb_split': '(string $pattern, string $string, int $limit = -1): array|false\nSplit multibyte string using regular expression',
	'mb_str_pad': '(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT, string|null $encoding = null): string\nPad a multibyte string to a certain length with another multibyte string',
	'mb_str_split': '(string $string, int $length = 1, string|null $encoding = null): array\nGiven a multibyte string, return an array of its characters',
	'mb_strcut': '(string $string, int $start, int|null $length = null, string|null $encoding = null): string\nGet part of string',
	'mb_strimwidth': '(string $string, int $start, int $width, string $trim_marker = "", string|null $encoding = null): string\nGet truncated string with specified width',
	'mb_stripos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of first occurrence of a string within another, case insensitive',
	'mb_stristr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds first occurrence of a string within another, case insensitive',
	'mb_strlen': '(string $string, string|null $encoding = null): int\nGet string length',
	'mb_strpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFind position of first occurrence of string in a string',
	'mb_strrchr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds the last occurrence of a character in a string within another',
	'mb_strrichr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds the last occurrence of a character in a string within another, case insensitive',
	'mb_strripos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFinds position of last occurrence of a string within another, case insensitive',
	'mb_strrpos': '(string $haystack, string $needle, int $offset = ?, string|null $encoding = null): int|false\nFind position of last occurrence of a string in a string',
	'mb_strstr': '(string $haystack, string $needle, bool $before_needle = false, string|null $encoding = null): string|false\nFinds first occurrence of a string within another',
	'mb_strtolower': '(string $string, string|null $encoding = null): string\nMake a string lowercase',
	'mb_strtoupper': '(string $string, string|null $encoding = null): string\nMake a string uppercase',
	'mb_strwidth': '(string $string, string|null $encoding = null): int\nReturn width of string',
	'mb_substitute_character': '(string|int|null $substitute_character = null): string|int|bool\nSet/Get substitution character',
	'mb_substr_count': '(string $haystack, string $needle, string|null $encoding = null): int\nCount the number of substring occurrences',
	'mb_substr': '(string $string, int $start, int|null $length = null, string|null $encoding = null): string\nGet part of string',
	'mb_trim': '(string $string, string|null $characters = null, string|null $encoding = null): string\nStrip whitespace (or other characters) from the beginning and end of a string',
	'mb_ucfirst': '(string $string, string|null $encoding = null): string\nMake a string\'s first character uppercase',
	'mhash_count': '(): int\nGets the highest available hash ID',
	'mhash_get_block_size': '(int $algo): int|false\nGets the block size of the specified hash',
	'mhash_get_hash_name': '(int $algo): string|false\nGets the name of the specified hash',
	'mhash_keygen_s2k': '(int $algo, string $password, string $salt, int $length): string|false\nGenerates a key',
	'mhash': '(int $algo, string $data, string|null $key = null): string|false\nComputes hash',
	'pcntl_alarm': '(int $seconds): int\nSet an alarm clock for delivery of a signal',
	'pcntl_async_signals': '(bool|null $enable = null): bool\nEnable/disable asynchronous signal handling or return the old setting',
	'pcntl_errno': 'Alias of pcntl_get_last_error',
	'pcntl_exec': '(string $path, array $args = [], array $env_vars = []): bool\nExecutes specified program in current process space',
	'pcntl_fork': '(): int\nForks the currently running process',
	'pcntl_get_last_error': '(): int\nRetrieve the error number set by the last pcntl function which failed',
	'pcntl_getcpuaffinity': '(int|null $pid = null): bool|array\nGet the cpu affinity of a process',
	'pcntl_getpriority': '(int|null $process_id = null, int $mode = PRIO_PROCESS): int|false\nGet the priority of any process',
	'pcntl_rfork': '(int $flags, int $signal = ?): int\nManipulates process resources',
	'pcntl_setcpuaffinity': '(int|null $pid = null, array $hmask = ?): bool\nSet the cpu affinity of a process',
	'pcntl_setpriority': '(int $priority, int|null $process_id = null, int $mode = PRIO_PROCESS): bool\nChange the priority of any process',
	'pcntl_signal_dispatch': '(): bool\nCalls signal handlers for pending signals',
	'pcntl_signal_get_handler': '(int $signal): callable|int\nGet the current handler for specified signal',
	'pcntl_signal': '(int $signal, callable|int $handler, bool $restart_syscalls = true): bool\nInstalls a signal handler',
	'pcntl_sigprocmask': '(int $mode, array $signals, array $old_signals = null): bool\nSets and retrieves blocked signals',
	'pcntl_sigtimedwait': '(array $signals, array $info = [], int $seconds = ?, int $nanoseconds = ?): int|false\nWaits for signals, with a timeout',
	'pcntl_sigwaitinfo': '(array $signals, array $info = []): int|false\nWaits for signals',
	'pcntl_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
	'pcntl_unshare': '(int $flags): bool\nDissociates parts of the process execution context',
	'pcntl_wait': '(int $status, int $flags = ?, array $resource_usage = []): int\nWaits on or returns the status of a forked child',
	'pcntl_waitid': '(int $idtype = P_ALL, int|null $id = null, array $info = [], int $flags = WEXITED): bool\nWaits for a child process to change state',
	'pcntl_waitpid': '(int $process_id, int $status, int $flags = ?, array $resource_usage = []): int\nWaits on or returns the status of a forked child',
	'pcntl_wexitstatus': '(int $status): int|false\nReturns the return code of a terminated child',
	'pcntl_wifexited': '(int $status): bool\nChecks if status code represents a normal exit',
	'pcntl_wifsignaled': '(int $status): bool\nChecks whether the status code represents a termination due to a signal',
	'pcntl_wifstopped': '(int $status): bool\nChecks whether the child process is currently stopped',
	'pcntl_wstopsig': '(int $status): int|false\nReturns the signal which caused the child to stop',
	'pcntl_wtermsig': '(int $status): int|false\nReturns the signal which caused the child to terminate',
	'PDO::beginTransaction': '(): bool\nInitiates a transaction',
	'PDO::commit': '(): bool\nCommits a transaction',
	'PDO::connect': '(string $dsn, string|null $username = null, string|null $password = null, array|null $options = null): static\nConnect to a database and return a PDO subclass for drivers that support it',
	'PDO::errorCode': '(): string|null\nFetch the SQLSTATE associated with the last operation on the database handle',
	'PDO::errorInfo': '(): array\nFetch extended error information associated with the last operation on the database handle',
	'PDO::exec': '(string $statement): int|false\nExecute an SQL statement and return the number of affected rows',
	'PDO::getAttribute': '(int $attribute): mixed\nRetrieve a database connection attribute',
	'PDO::getAvailableDrivers': '(): array\nReturn an array of available PDO drivers',
	'pdo_drivers': '(): array\nReturn an array of available PDO drivers',
	'PDO::inTransaction': '(): bool\nChecks if inside a transaction',
	'PDO::lastInsertId': '(string|null $name = null): string|false\nReturns the ID of the last inserted row or sequence value',
	'PDO::prepare': '(string $query, array $options = []): PDOStatement|false\nPrepares a statement for execution and returns a statement object',
	'PDO::query': '(string $query, int|null $fetchMode = null): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
	'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_COLUMN, int $colno): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
	'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_CLASS, string $classname, array $constructorArgs): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
	'PDO::query': '(string $query, int|null $fetchMode = PDO::FETCH_INTO, object $object): PDOStatement|false\nPrepares and executes an SQL statement without placeholders',
	'PDO::quote': '(string $string, int $type = PDO::PARAM_STR): string|false\nQuotes a string for use in a query',
	'PDO::rollBack': '(): bool\nRolls back a transaction',
	'PDO::setAttribute': '(int $attribute, mixed $value): bool\nSet an attribute',
	'PDOStatement::bindColumn': '(string|int $column, mixed $var, int $type = PDO::PARAM_STR, int $maxLength = ?, mixed $driverOptions = null): bool\nBind a column to a PHP variable',
	'PDOStatement::bindParam': '(string|int $param, mixed $var, int $type = PDO::PARAM_STR, int $maxLength = ?, mixed $driverOptions = null): bool\nBinds a parameter to the specified variable name',
	'PDOStatement::bindValue': '(string|int $param, mixed $value, int $type = PDO::PARAM_STR): bool\nBinds a value to a parameter',
	'PDOStatement::closeCursor': '(): bool\nCloses the cursor, enabling the statement to be executed again',
	'PDOStatement::columnCount': '(): int\nReturns the number of columns in the result set',
	'PDOStatement::debugDumpParams': '(): bool|null\nDump an SQL prepared command',
	'PDOStatement::errorCode': '(): string|null\nFetch the SQLSTATE associated with the last operation on the statement handle',
	'PDOStatement::errorInfo': '(): array\nFetch extended error information associated with the last operation on the statement handle',
	'PDOStatement::execute': '(array|null $params = null): bool\nExecutes a prepared statement',
	'PDOStatement::fetch': '(int $mode = PDO::FETCH_DEFAULT, int $cursorOrientation = PDO::FETCH_ORI_NEXT, int $cursorOffset = ?): mixed\nFetches the next row from a result set',
	'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_DEFAULT): array\nFetches the remaining rows from a result set',
	'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_COLUMN, int $column): array\nFetches the remaining rows from a result set',
	'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_CLASS, string $class, array|null $constructorArgs): array\nFetches the remaining rows from a result set',
	'PDOStatement::fetchAll': '(int $mode = PDO::FETCH_FUNC, callable $callback): array\nFetches the remaining rows from a result set',
	'PDOStatement::fetchColumn': '(int $column = ?): mixed\nReturns a single column from the next row of a result set',
	'PDOStatement::fetchObject': '(string|null $class = "stdClass", array $constructorArgs = []): object|false\nFetches the next row and returns it as an object',
	'PDOStatement::getAttribute': '(int $name): mixed\nRetrieve a statement attribute',
	'PDOStatement::getColumnMeta': '(int $column): array|false\nReturns metadata for a column in a result set',
	'PDOStatement::getIterator': '(): Iterator\nGets result set iterator',
	'PDOStatement::nextRowset': '(): bool\nAdvances to the next rowset in a multi-rowset statement handle',
	'PDOStatement::rowCount': '(): int\nReturns the number of rows affected by the last SQL statement',
	'PDOStatement::setAttribute': '(int $attribute, mixed $value): bool\nSet a statement attribute',
	'PDOStatement::setFetchMode': '(int $mode): bool\nSet the default fetch mode for this statement',
	'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_COLUMN, int $colno): bool\nSet the default fetch mode for this statement',
	'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_CLASS, string $class, array|null $constructorArgs = null): bool\nSet the default fetch mode for this statement',
	'PDOStatement::setFetchMode': '(int $mode = PDO::FETCH_INTO, object $object): bool\nSet the default fetch mode for this statement',
	'Phar::addEmptyDir': '(string $directory): void\nAdd an empty directory to the phar archive',
	'Phar::addFile': '(string $filename, string|null $localName = null): void\nAdd a file from the filesystem to the phar archive',
	'Phar::addFromString': '(string $localName, string $contents): void\nAdd a file from a string to the phar archive',
	'Phar::apiVersion': '(): string\nReturns the api version',
	'Phar::buildFromDirectory': '(string $directory, string $pattern = ""): array\nConstruct a phar archive from the files within a directory',
	'Phar::buildFromIterator': '(Traversable $iterator, string|null $baseDirectory = null): array\nConstruct a phar archive from an iterator',
	'Phar::canCompress': '(int $compression = ?): bool\nReturns whether phar extension supports compression using either zlib or bzip2',
	'Phar::canWrite': '(): bool\nReturns whether phar extension supports writing and creating phars',
	'Phar::compress': '(int $compression, string|null $extension = null): Phar|null\nCompresses the entire Phar archive using Gzip or Bzip2 compression',
	'Phar::compressFiles': '(int $compression): void\nCompresses all files in the current Phar archive',
	'Phar::convertToData': '(int|null $format = null, int|null $compression = null, string|null $extension = null): PharData|null\nConvert a phar archive to a non-executable tar or zip file',
	'Phar::convertToExecutable': '(int|null $format = null, int|null $compression = null, string|null $extension = null): Phar|null\nConvert a phar archive to another executable phar archive file format',
	'Phar::copy': '(string $from, string $to): true\nCopy a file internal to the phar archive to another new file within the phar',
	'Phar::count': '(int $mode = COUNT_NORMAL): int\nReturns the number of entries (files) in the Phar archive',
	'Phar::createDefaultStub': '(string|null $index = null, string|null $webIndex = null): string\nCreate a phar-file format specific stub',
	'Phar::decompress': '(string|null $extension = null): Phar|null\nDecompresses the entire Phar archive',
	'Phar::decompressFiles': '(): true\nDecompresses all files in the current Phar archive',
	'Phar::delMetadata': '(): true\nDeletes the global metadata of the phar',
	'Phar::delete': '(string $localName): true\nDelete a file within a phar archive',
	'Phar::extractTo': '(string $directory, array|string|null $files = null, bool $overwrite = false): bool\nExtract the contents of a phar archive to a directory',
	'Phar::getAlias': '(): string|null\nGet the alias for Phar',
	'Phar::getMetadata': '(array $unserializeOptions = []): mixed\nReturns phar archive meta-data',
	'Phar::getModified': '(): bool\nReturn whether phar was modified',
	'Phar::getPath': '(): string\nGet the real path to the Phar archive on disk',
	'Phar::getSignature': '(): array|false\nReturn MD5/SHA1/SHA256/SHA512/OpenSSL signature of a Phar archive',
	'Phar::getStub': '(): string\nReturn the PHP loader or bootstrap stub of a Phar archive',
	'Phar::getSupportedCompression': '(): array\nReturn array of supported compression algorithms',
	'Phar::getSupportedSignatures': '(): array\nReturn array of supported signature types',
	'Phar::getVersion': '(): string\nReturn version info of Phar archive',
	'Phar::hasMetadata': '(): bool\nReturns whether phar has global meta-data',
	'Phar::interceptFileFuncs': '(): void\nInstructs phar to intercept fopen, file_get_contents, opendir, and all of the stat-related functions',
	'Phar::isBuffering': '(): bool\nUsed to determine whether Phar write operations are being buffered, or are flushing directly to disk',
	'Phar::isCompressed': '(): int|false\nReturns Phar::GZ or PHAR::BZ2 if the entire phar archive is compressed (.tar.gz/tar.bz and so on)',
	'Phar::isFileFormat': '(int $format): bool\nReturns true if the phar archive is based on the tar/phar/zip file format depending on the parameter',
	'Phar::isValidPharFilename': '(string $filename, bool $executable = true): bool\nReturns whether the given filename is a valid phar filename',
	'Phar::isWritable': '(): bool\nReturns true if the phar archive can be modified',
	'Phar::loadPhar': '(string $filename, string|null $alias = null): bool\nLoads any phar archive with an alias',
	'Phar::mapPhar': '(string|null $alias = null, int $offset = ?): bool\nReads the currently executed file (a phar) and registers its manifest',
	'Phar::mount': '(string $pharPath, string $externalPath): void\nMount an external path or file to a virtual location within the phar archive',
	'Phar::mungServer': '(array $variables): void\nDefines a list of up to 4 $_SERVER variables that should be modified for execution',
	'Phar::offsetExists': '(string $localName): bool\nDetermines whether a file exists in the phar',
	'Phar::offsetGet': '(string $localName): SplFileInfo\nGets a PharFileInfo object for a specific file',
	'Phar::offsetSet': '(string $localName, resource|string $value): void\nSet the contents of an internal file to those of an external file',
	'Phar::offsetUnset': '(string $localName): void\nRemove a file from a phar',
	'Phar::running': '(bool $returnPhar = true): string\nReturns the full path on disk or full phar URL to the currently executing Phar archive',
	'Phar::setAlias': '(string $alias): true\nSet the alias for the Phar archive',
	'Phar::setDefaultStub': '(string|null $index = null, string|null $webIndex = null): true\nUsed to set the PHP loader or bootstrap stub of a Phar archive to the default loader',
	'Phar::setMetadata': '(mixed $metadata): void\nSets phar archive meta-data',
	'Phar::setSignatureAlgorithm': '(int $algo, string|null $privateKey = null): void\nSet the signature algorithm for a phar and apply it',
	'Phar::setStub': '(resource|string $stub, int $length = -1): bool\nUsed to set the PHP loader or bootstrap stub of a Phar archive',
	'Phar::startBuffering': '(): void\nStart buffering Phar write operations, do not modify the Phar object on disk',
	'Phar::stopBuffering': '(): void\nStop buffering write requests to the Phar archive, and save changes to disk',
	'Phar::unlinkArchive': '(string $filename): true\nCompletely remove a phar archive from disk and from memory',
	'Phar::webPhar': '(string|null $alias = null, string|null $index = null, string|null $fileNotFoundScript = null, array $mimeTypes = [], callable|null $rewrite = null): void\nRoutes a request from a web browser to an internal file within the phar archive',
	'PharData::addEmptyDir': '(string $directory): void\nAdd an empty directory to the tar/zip archive',
	'PharData::addFile': '(string $filename, string|null $localName = null): void\nAdd a file from the filesystem to the tar/zip archive',
	'PharData::addFromString': '(string $localName, string $contents): void\nAdd a file from a string to the tar/zip archive',
	'PharData::buildFromDirectory': '(string $directory, string $pattern = ""): array\nConstruct a tar/zip archive from the files within a directory',
	'PharData::buildFromIterator': '(Traversable $iterator, string|null $baseDirectory = null): array\nConstruct a tar or zip archive from an iterator',
	'PharData::compress': '(int $compression, string|null $extension = null): PharData|null\nCompresses the entire tar/zip archive using Gzip or Bzip2 compression',
	'PharData::compressFiles': '(int $compression): void\nCompresses all files in the current tar/zip archive',
	'PharData::convertToData': '(int|null $format = null, int|null $compression = null, string|null $extension = null): PharData|null\nConvert a phar archive to a non-executable tar or zip file',
	'PharData::convertToExecutable': '(int|null $format = null, int|null $compression = null, string|null $extension = null): Phar|null\nConvert a non-executable tar/zip archive to an executable phar archive',
	'PharData::copy': '(string $from, string $to): true\nCopy a file internal to the tar/zip archive to another new file within the same archive',
	'PharData::decompress': '(string|null $extension = null): PharData|null\nDecompresses the entire Phar archive',
	'PharData::decompressFiles': '(): true\nDecompresses all files in the current zip archive',
	'PharData::delMetadata': '(): true\nDeletes the global metadata of a zip archive',
	'PharData::delete': '(string $localName): true\nDelete a file within a tar/zip archive',
	'PharData::extractTo': '(string $directory, array|string|null $files = null, bool $overwrite = false): bool\nExtract the contents of a tar/zip archive to a directory',
	'PharData::isWritable': '(): bool\nReturns true if the tar/zip archive can be modified',
	'PharData::offsetSet': '(string $localName, resource|string $value): void\nSet the contents of a file within the tar/zip to those of an external file or string',
	'PharData::offsetUnset': '(string $localName): void\nRemove a file from a tar/zip archive',
	'PharData::setAlias': '(string $alias): bool\nDummy function (Phar::setAlias is not valid for PharData)',
	'PharData::setDefaultStub': '(string|null $index = null, string|null $webIndex = null): bool\nDummy function (Phar::setDefaultStub is not valid for PharData)',
	'PharData::setMetadata': '(mixed $metadata): void\nSets phar archive meta-data',
	'PharData::setSignatureAlgorithm': '(int $algo, string|null $privateKey = null): void\nSet the signature algorithm for a phar and apply it',
	'PharData::setStub': '(string $stub, int $len = -1): bool\nDummy function (Phar::setStub is not valid for PharData)',
	'PharFileInfo::chmod': '(int $perms): void\nSets file-specific permission bits',
	'PharFileInfo::compress': '(int $compression): true\nCompresses the current Phar entry with either zlib or bzip2 compression',
	'PharFileInfo::decompress': '(): true\nDecompresses the current Phar entry within the phar',
	'PharFileInfo::delMetadata': '(): true\nDeletes the metadata of the entry',
	'PharFileInfo::getCRC32': '(): int\nReturns CRC32 code or throws an exception if CRC has not been verified',
	'PharFileInfo::getCompressedSize': '(): int\nReturns the actual size of the file (with compression) inside the Phar archive',
	'PharFileInfo::getContent': '(): string\nGet the complete file contents of the entry',
	'PharFileInfo::getMetadata': '(array $unserializeOptions = []): mixed\nReturns file-specific meta-data saved with a file',
	'PharFileInfo::getPharFlags': '(): int\nReturns the Phar file entry flags',
	'PharFileInfo::hasMetadata': '(): bool\nReturns the metadata of the entry',
	'PharFileInfo::isCRCChecked': '(): bool\nReturns whether file entry has had its CRC verified',
	'PharFileInfo::isCompressed': '(int|null $compression = null): bool\nReturns whether the entry is compressed',
	'PharFileInfo::setMetadata': '(mixed $metadata): void\nSets file-specific meta-data saved with a file',
	'phpdbg_break_file': '(string $file, int $line): void\nInserts a breakpoint at a line in a file',
	'phpdbg_break_function': '(string $function): void\nInserts a breakpoint at entry to a function',
	'phpdbg_break_method': '(string $class, string $method): void\nInserts a breakpoint at entry to a method',
	'phpdbg_break_next': '(): void\nInserts a breakpoint at the next opcode',
	'phpdbg_clear': '(): void\nClears all breakpoints',
	'phpdbg_color': '(int $element, string $color): void\nSets the color of certain elements',
	'phpdbg_end_oplog': '(array $options = []): array|null\n',
	'phpdbg_exec': '(string $context): string|bool\nAttempts to set the execution context',
	'phpdbg_get_executable': '(array $options = []): array\n',
	'phpdbg_prompt': '(string $string): void\nSets the command prompt',
	'phpdbg_start_oplog': '(): void\n',
	'posix_access': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
	'posix_ctermid': '(): string|false\nGet path name of controlling terminal',
	'posix_eaccess': '(string $filename, int $flags = ?): bool\nDetermine accessibility of a file',
	'posix_errno': 'Alias of posix_get_last_error',
	'posix_fpathconf': '(resource|int $file_descriptor, int $name): int|false\nReturns the value of a configurable limit',
	'posix_get_last_error': '(): int\nRetrieve the error number set by the last posix function that failed',
	'posix_getcwd': '(): string|false\nPathname of current directory',
	'posix_getegid': '(): int\nReturn the effective group ID of the current process',
	'posix_geteuid': '(): int\nReturn the effective user ID of the current process',
	'posix_getgid': '(): int\nReturn the real group ID of the current process',
	'posix_getgrgid': '(int $group_id): array|false\nReturn info about a group by group id',
	'posix_getgrnam': '(string $name): array|false\nReturn info about a group by name',
	'posix_getgroups': '(): array|false\nReturn the group set of the current process',
	'posix_getlogin': '(): string|false\nReturn login name',
	'posix_getpgid': '(int $process_id): int|false\nGet process group id for job control',
	'posix_getpgrp': '(): int\nReturn the current process group identifier',
	'posix_getpid': '(): int\nReturn the current process identifier',
	'posix_getppid': '(): int\nReturn the parent process identifier',
	'posix_getpwnam': '(string $username): array|false\nReturn info about a user by username',
	'posix_getpwuid': '(int $user_id): array|false\nReturn info about a user by user id',
	'posix_getrlimit': '(int|null $resource = null): array|false\nReturn info about system resource limits',
	'posix_getsid': '(int $process_id): int|false\nGet the current sid of the process',
	'posix_getuid': '(): int\nReturn the real user ID of the current process',
	'posix_initgroups': '(string $username, int $group_id): bool\nCalculate the group access list',
	'posix_isatty': '(resource|int $file_descriptor): bool\nDetermine if a file descriptor is an interactive terminal',
	'posix_kill': '(int $process_id, int $signal): bool\nSend a signal to a process',
	'posix_mkfifo': '(string $filename, int $permissions): bool\nCreate a fifo special file (a named pipe)',
	'posix_mknod': '(string $filename, int $flags, int $major = ?, int $minor = ?): bool\nCreate a special or ordinary file (POSIX.1)',
	'posix_pathconf': '(string $path, int $name): int|false\nReturns the value of a configurable limit',
	'posix_setegid': '(int $group_id): bool\nSet the effective GID of the current process',
	'posix_seteuid': '(int $user_id): bool\nSet the effective UID of the current process',
	'posix_setgid': '(int $group_id): bool\nSet the GID of the current process',
	'posix_setpgid': '(int $process_id, int $process_group_id): bool\nSet process group id for job control',
	'posix_setrlimit': '(int $resource, int $soft_limit, int $hard_limit): bool\nSet system resource limits',
	'posix_setsid': '(): int\nMake the current process a session leader',
	'posix_setuid': '(int $user_id): bool\nSet the UID of the current process',
	'posix_strerror': '(int $error_code): string\nRetrieve the system error message associated with the given errno',
	'posix_sysconf': '(int $conf_id): int\nReturns system runtime information',
	'posix_times': '(): array|false\nGet process times',
	'posix_ttyname': '(resource|int $file_descriptor): string|false\nDetermine terminal device name',
	'posix_uname': '(): array|false\nGet system name',
	'ftok': '(string $filename, string $project_id): int\nConvert a pathname and a project identifier to a System V IPC key',
	'msg_get_queue': '(int $key, int $permissions = 0666): SysvMessageQueue|false\nCreate or attach to a message queue',
	'msg_queue_exists': '(int $key): bool\nCheck whether a message queue exists',
	'msg_receive': '(SysvMessageQueue $queue, int $desired_message_type, int $received_message_type, int $max_message_size, mixed $message, bool $unserialize = true, int $flags = ?, int $error_code = null): bool\nReceive a message from a message queue',
	'msg_remove_queue': '(SysvMessageQueue $queue): bool\nDestroy a message queue',
	'msg_send': '(SysvMessageQueue $queue, int $message_type, string|int|float|bool $message, bool $serialize = true, bool $blocking = true, int $error_code = null): bool\nSend a message to a message queue',
	'msg_set_queue': '(SysvMessageQueue $queue, array $data): bool\nSet information in the message queue data structure',
	'msg_stat_queue': '(SysvMessageQueue $queue): array|false\nReturns information from the message queue data structure',
	'sem_acquire': '(SysvSemaphore $semaphore, bool $non_blocking = false): bool\nAcquire a semaphore',
	'sem_get': '(int $key, int $max_acquire = 1, int $permissions = 0666, bool $auto_release = true): SysvSemaphore|false\nGet a semaphore id',
	'sem_release': '(SysvSemaphore $semaphore): bool\nRelease a semaphore',
	'sem_remove': '(SysvSemaphore $semaphore): bool\nRemove a semaphore',
	'shm_attach': '(int $key, int|null $size = null, int $permissions = 0666): SysvSharedMemory|false\nCreates or open a shared memory segment',
	'shm_detach': '(SysvSharedMemory $shm): bool\nDisconnects from shared memory segment',
	'shm_get_var': '(SysvSharedMemory $shm, int $key): mixed\nReturns a variable from shared memory',
	'shm_has_var': '(SysvSharedMemory $shm, int $key): bool\nCheck whether a specific entry exists',
	'shm_put_var': '(SysvSharedMemory $shm, int $key, mixed $value): bool\nInserts or updates a variable in shared memory',
	'shm_remove_var': '(SysvSharedMemory $shm, int $key): bool\nRemoves a variable from shared memory',
	'shm_remove': '(SysvSharedMemory $shm): bool\nRemoves shared memory from Unix systems',
	'session_abort': '(): bool\nDiscard session array changes and finish session',
	'session_cache_expire': '(int|null $value = null): int|false\nGet and/or set current cache expire',
	'session_cache_limiter': '(string|null $value = null): string|false\nGet and/or set the current cache limiter',
	'session_commit': 'Alias of session_write_close',
	'session_create_id': '(string $prefix = ""): string|false\nCreate new session id',
	'session_decode': '(string $data): bool\nDecodes session data from a session encoded string',
	'session_destroy': '(): bool\nDestroys all data registered to a session',
	'session_encode': '(): string|false\nEncodes the current session data as a session encoded string',
	'session_gc': '(): int|false\nPerform session data garbage collection',
	'session_get_cookie_params': '(): array\nGet the session cookie parameters',
	'session_id': '(string|null $id = null): string|false\nGet and/or set the current session id',
	'session_module_name': '(string|null $module = null): string|false\nGet and/or set the current session module',
	'session_name': '(string|null $name = null): string|false\nGet and/or set the current session name',
	'session_regenerate_id': '(bool $delete_old_session = false): bool\nUpdate the current session id with a newly generated one',
	'session_register_shutdown': '(): void\nSession shutdown function',
	'session_reset': '(): bool\nRe-initialize session array with original values',
	'session_save_path': '(string|null $path = null): string|false\nGet and/or set the current session save path',
	'session_set_cookie_params': '(int $lifetime_or_options, string|null $path = null, string|null $domain = null, bool|null $secure = null, bool|null $httponly = null): bool\nSet the session cookie parameters',
	'session_set_cookie_params': '(array $lifetime_or_options): bool\nSet the session cookie parameters',
	'session_set_save_handler': '(callable $open, callable $close, callable $read, callable $write, callable $destroy, callable $gc, callable $create_sid = ?, callable $validate_sid = ?, callable $update_timestamp = ?): bool\nSets user-level session storage functions',
	'session_set_save_handler': '(object $sessionhandler, bool $register_shutdown = true): bool\nSets user-level session storage functions',
	'session_start': '(array $options = []): bool\nStart new or resume existing session',
	'session_status': '(): int\nReturns the current session status',
	'session_unset': '(): bool\nFree all session variables',
	'session_write_close': '(): bool\nWrite session data and end session',
	'SessionHandler::close': '(): bool\nClose the session',
	'SessionHandler::create_sid': '(): string\nReturn a new session ID',
	'SessionHandler::destroy': '(string $id): bool\nDestroy a session',
	'SessionHandler::gc': '(int $max_lifetime): int|false\nCleanup old sessions',
	'SessionHandler::open': '(string $path, string $name): bool\nInitialize session',
	'SessionHandler::read': '(string $id): string|false\nRead session data',
	'SessionHandler::write': '(string $id, string $data): bool\nWrite session data',
	'SessionHandlerInterface::close': '(): bool\nClose the session',
	'SessionHandlerInterface::destroy': '(string $id): bool\nDestroy a session',
	'SessionHandlerInterface::gc': '(int $max_lifetime): int|false\nCleanup old sessions',
	'SessionHandlerInterface::open': '(string $path, string $name): bool\nInitialize session',
	'SessionHandlerInterface::read': '(string $id): string|false\nRead session data',
	'SessionHandlerInterface::write': '(string $id, string $data): bool\nWrite session data',
	'SessionIdInterface::create_sid': '(): string\nCreate session ID',
	'SessionUpdateTimestampHandlerInterface::updateTimestamp': '(string $id, string $data): bool\nUpdate timestamp',
	'SessionUpdateTimestampHandlerInterface::validateId': '(string $id): bool\nValidate ID',
	'shmop_close': '(Shmop $shmop): void\nClose shared memory block',
	'shmop_delete': '(Shmop $shmop): bool\nDelete shared memory block',
	'shmop_open': '(int $key, string $mode, int $permissions, int $size): Shmop|false\nCreate or open shared memory block',
	'shmop_read': '(Shmop $shmop, int $offset, int $size): string\nRead data from shared memory block',
	'shmop_size': '(Shmop $shmop): int\nGet size of shared memory block',
	'shmop_write': '(Shmop $shmop, string $data, int $offset): int\nWrite data into shared memory block',
	'socket_accept': '(Socket $socket): Socket|false\nAccepts a connection on a socket',
	'socket_addrinfo_bind': '(AddressInfo $address): Socket|false\nCreate and bind to a socket from a given addrinfo',
	'socket_addrinfo_connect': '(AddressInfo $address): Socket|false\nCreate and connect to a socket from a given addrinfo',
	'socket_addrinfo_explain': '(AddressInfo $address): array\nGet information about addrinfo',
	'socket_addrinfo_lookup': '(string $host, string|null $service = null, array $hints = []): array|false\nGet array with contents of getaddrinfo about the given hostname',
	'socket_atmark': '(Socket $socket): bool\nDetermines whether socket is at out-of-band mark',
	'socket_bind': '(Socket $socket, string $address, int $port = ?): bool\nBinds a name to a socket',
	'socket_clear_error': '(Socket|null $socket = null): void\nClears the error on the socket or the last error code',
	'socket_close': '(Socket $socket): void\nCloses a Socket instance',
	'socket_cmsg_space': '(int $level, int $type, int $num = ?): int|null\nCalculate message buffer size',
	'socket_connect': '(Socket $socket, string $address, int|null $port = null): bool\nInitiates a connection on a socket',
	'socket_create_listen': '(int $port, int $backlog = SOMAXCONN): Socket|false\nOpens a socket on port to accept connections',
	'socket_create_pair': '(int $domain, int $type, int $protocol, array $pair): bool\nCreates a pair of indistinguishable sockets and stores them in an array',
	'socket_create': '(int $domain, int $type, int $protocol): Socket|false\nCreate a socket (endpoint for communication)',
	'socket_export_stream': '(Socket $socket): resource|false\nExport a socket into a stream that encapsulates a socket',
	'socket_get_option': '(Socket $socket, int $level, int $option): array|int|false\nGets socket options for the socket',
	'socket_getopt': 'Alias of socket_get_option',
	'socket_getpeername': '(Socket $socket, string $address, int $port = null): bool\nQueries the remote side of the given socket',
	'socket_getsockname': '(Socket $socket, string $address, int $port = null): bool\nQueries the local side of the given socket which may either result in host/port or in a Unix filesystem path, dependent on its type',
	'socket_import_stream': '(resource $stream): Socket|false\nImport a stream',
	'socket_last_error': '(Socket|null $socket = null): int\nReturns the last error on the socket',
	'socket_listen': '(Socket $socket, int $backlog = ?): bool\nListens for a connection on a socket',
	'socket_read': '(Socket $socket, int $length, int $mode = PHP_BINARY_READ): string|false\nReads a maximum of length bytes from a socket',
	'socket_recv': '(Socket $socket, string|null $data, int $length, int $flags): int|false\nReceives data from a connected socket',
	'socket_recvfrom': '(Socket $socket, string $data, int $length, int $flags, string $address, int $port = null): int|false\nReceives data from a socket whether or not it is connection-oriented',
	'socket_recvmsg': '(Socket $socket, array $message, int $flags = ?): int|false\nRead a message',
	'socket_select': '(array|null $read, array|null $write, array|null $except, int|null $seconds, int $microseconds = ?): int|false\nRuns the select() system call on the given arrays of sockets with a specified timeout',
	'socket_send': '(Socket $socket, string $data, int $length, int $flags): int|false\nSends data to a connected socket',
	'socket_sendmsg': '(Socket $socket, array $message, int $flags = ?): int|false\nSend a message',
	'socket_sendto': '(Socket $socket, string $data, int $length, int $flags, string $address, int|null $port = null): int|false\nSends a message to a socket, whether it is connected or not',
	'socket_set_block': '(Socket $socket): bool\nSets blocking mode on a socket',
	'socket_set_nonblock': '(Socket $socket): bool\nSets nonblocking mode for file descriptor fd',
	'socket_set_option': '(Socket $socket, int $level, int $option, array|string|int $value): bool\nSets socket options for the socket',
	'socket_setopt': 'Alias of socket_set_option',
	'socket_shutdown': '(Socket $socket, int $mode = 2): bool\nShuts down a socket for receiving, sending, or both',
	'socket_strerror': '(int $error_code): string\nReturn a string describing a socket error',
	'socket_write': '(Socket $socket, string $data, int|null $length = null): int|false\nWrite to a socket',
	'socket_wsaprotocol_info_export': '(Socket $socket, int $process_id): string|false\nExports the WSAPROTOCOL_INFO Structure',
	'socket_wsaprotocol_info_import': '(string $info_id): Socket|false\nImports a Socket from another Process',
	'socket_wsaprotocol_info_release': '(string $info_id): bool\nReleases an exported WSAPROTOCOL_INFO Structure',
	'SQLite3::backup': '(SQLite3 $destination, string $sourceDatabase = "main", string $destinationDatabase = "main"): bool\nBackup one database to another database',
	'SQLite3::busyTimeout': '(int $milliseconds): bool\nSets the busy connection handler',
	'SQLite3::changes': '(): int\nReturns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement',
	'SQLite3::close': '(): bool\nCloses the database connection',
	'SQLite3::createAggregate': '(string $name, callable $stepCallback, callable $finalCallback, int $argCount = -1): bool\nRegisters a PHP function for use as an SQL aggregate function',
	'SQLite3::createCollation': '(string $name, callable $callback): bool\nRegisters a PHP function for use as an SQL collating function',
	'SQLite3::createFunction': '(string $name, callable $callback, int $argCount = -1, int $flags = ?): bool\nRegisters a PHP function for use as an SQL scalar function',
	'SQLite3::enableExceptions': '(bool $enable = false): bool\nEnable throwing exceptions',
	'SQLite3::escapeString': '(string $string): string\nReturns a string that has been properly escaped',
	'SQLite3::exec': '(string $query): bool\nExecutes a result-less query against a given database',
	'SQLite3::lastErrorCode': '(): int\nReturns the numeric result code of the most recent failed SQLite request',
	'SQLite3::lastErrorMsg': '(): string\nReturns English text describing the most recent failed SQLite request',
	'SQLite3::lastInsertRowID': '(): int\nReturns the row ID of the most recent INSERT into the database',
	'SQLite3::loadExtension': '(string $name): bool\nAttempts to load an SQLite extension library',
	'SQLite3::open': '(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryptionKey = ""): void\nOpens an SQLite database',
	'SQLite3::openBlob': '(string $table, string $column, int $rowid, string $database = "main", int $flags = SQLITE3_OPEN_READONLY): resource|false\nOpens a stream resource to read a BLOB',
	'SQLite3::prepare': '(string $query): SQLite3Stmt|false\nPrepares an SQL statement for execution',
	'SQLite3::query': '(string $query): SQLite3Result|false\nExecutes an SQL query',
	'SQLite3::querySingle': '(string $query, bool $entireRow = false): mixed\nExecutes a query and returns a single result',
	'SQLite3::setAuthorizer': '(callable|null $callback): bool\nConfigures a callback to be used as an authorizer to limit what a statement can do',
	'SQLite3::version': '(): array\nReturns the SQLite3 library version as a string constant and as a number',
	'SQLite3Result::columnName': '(int $column): string|false\nReturns the name of the nth column',
	'SQLite3Result::columnType': '(int $column): int|false\nReturns the type of the nth column',
	'SQLite3Result::fetchArray': '(int $mode = SQLITE3_BOTH): array|false\nFetches a result row as an associative or numerically indexed array or both',
	'SQLite3Result::finalize': '(): true\nCloses the result set',
	'SQLite3Result::numColumns': '(): int\nReturns the number of columns in the result set',
	'SQLite3Result::reset': '(): bool\nResets the result set back to the first row',
	'SQLite3Stmt::bindParam': '(string|int $param, mixed $var, int $type = SQLITE3_TEXT): bool\nBinds a parameter to a statement variable',
	'SQLite3Stmt::bindValue': '(string|int $param, mixed $value, int $type = SQLITE3_TEXT): bool\nBinds the value of a parameter to a statement variable',
	'SQLite3Stmt::clear': '(): bool\nClears all current bound parameters',
	'SQLite3Stmt::close': '(): true\nCloses the prepared statement',
	'SQLite3Stmt::execute': '(): SQLite3Result|false\nExecutes a prepared statement and returns a result set object',
	'SQLite3Stmt::getSQL': '(bool $expand = false): string|false\nGet the SQL of the statement',
	'SQLite3Stmt::paramCount': '(): int\nReturns the number of parameters within the prepared statement',
	'SQLite3Stmt::readOnly': '(): bool\nReturns whether a statement is definitely read only',
	'SQLite3Stmt::reset': '(): bool\nResets the prepared statement',
	'token_get_all': '(string $code, int $flags = ?): array\nSplit given source into PHP tokens',
	'token_name': '(int $id): string\nGet the symbolic name of a given PHP token',
	'PhpToken::getTokenName': '(): string|null\nReturns the name of the token.',
	'PhpToken::is': '(int|string|array $kind): bool\nTells whether the token is of given kind.',
	'PhpToken::isIgnorable': '(): bool\nTells whether the token would be ignored by the PHP parser.',
	'PhpToken::__toString': '(): string\nReturns the textual content of the token.',
	'PhpToken::tokenize': '(string $code, int $flags = ?): array\nSplits given source into PHP tokens, represented by PhpToken objects.',
	'deflate_add': '(DeflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally deflate data',
	'deflate_init': '(int $encoding, array $options = []): DeflateContext|false\nInitialize an incremental deflate context',
	'gzclose': '(resource $stream): bool\nClose an open gz-file pointer',
	'gzcompress': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_DEFLATE): string|false\nCompress a string',
	'gzdecode': '(string $data, int $max_length = ?): string|false\nDecodes a gzip compressed string',
	'gzdeflate': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_RAW): string|false\nDeflate a string',
	'gzencode': '(string $data, int $level = -1, int $encoding = ZLIB_ENCODING_GZIP): string|false\nCreate a gzip compressed string',
	'gzeof': '(resource $stream): bool\nTest for EOF on a gz-file pointer',
	'gzfile': '(string $filename, int $use_include_path = ?): array|false\nRead entire gz-file into an array',
	'gzgetc': '(resource $stream): string|false\nGet character from gz-file pointer',
	'gzgets': '(resource $stream, int|null $length = null): string|false\nGet line from file pointer',
	'gzgetss': '(resource $zp, int $length, string $allowable_tags = ?): string\nGet line from gz-file pointer and strip HTML tags',
	'gzinflate': '(string $data, int $max_length = ?): string|false\nInflate a deflated string',
	'gzopen': '(string $filename, string $mode, int $use_include_path = ?): resource|false\nOpen gz-file',
	'gzpassthru': '(resource $stream): int\nOutput all remaining data on a gz-file pointer',
	'gzputs': 'Alias of gzwrite',
	'gzread': '(resource $stream, int $length): string|false\nBinary-safe gz-file read',
	'gzrewind': '(resource $stream): bool\nRewind the position of a gz-file pointer',
	'gzseek': '(resource $stream, int $offset, int $whence = SEEK_SET): int\nSeek on a gz-file pointer',
	'gztell': '(resource $stream): int|false\nTell gz-file pointer read/write position',
	'gzuncompress': '(string $data, int $max_length = ?): string|false\nUncompress a compressed string',
	'gzwrite': '(resource $stream, string $data, int|null $length = null): int|false\nBinary-safe gz-file write',
	'inflate_get_read_len': '(InflateContext $context): int\nGet number of bytes read so far',
	'inflate_get_status': '(InflateContext $context): int\nGet decompression status',
	'inflate_add': '(InflateContext $context, string $data, int $flush_mode = ZLIB_SYNC_FLUSH): string|false\nIncrementally inflate encoded data',
	'inflate_init': '(int $encoding, array $options = []): InflateContext|false\nInitialize an incremental inflate context',
	'ob_gzhandler': '(string $data, int $flags): string|false\nob_start callback function to gzip output buffer',
	'readgzfile': '(string $filename, int $use_include_path = ?): int|false\nOutput a gz-file',
	'zlib_decode': '(string $data, int $max_length = ?): string|false\nUncompress any raw/gzip/zlib encoded data',
	'zlib_encode': '(string $data, int $encoding, int $level = -1): string|false\nCompress data with the specified encoding',
	'zlib_get_coding_type': '(): string|false\nReturns the coding type used for output compression',
	'bzclose': '(resource $bz): bool\nClose a bzip2 file',
	'bzcompress': '(string $data, int $block_size = 4, int $work_factor = ?): string|int\nCompress a string into bzip2 encoded data',
	'bzdecompress': '(string $data, bool $use_less_memory = false): string|int|false\nDecompresses bzip2 encoded data',
	'bzerrno': '(resource $bz): int\nReturns a bzip2 error number',
	'bzerror': '(resource $bz): array\nReturns the bzip2 error number and error string in an array',
	'bzerrstr': '(resource $bz): string\nReturns a bzip2 error string',
	'bzflush': '(resource $bz): bool\nDo nothing',
	'bzopen': '(string|resource $file, string $mode): resource|false\nOpens a bzip2 compressed file',
	'bzread': '(resource $bz, int $length = 1024): string|false\nBinary safe bzip2 file read',
	'bzwrite': '(resource $bz, string $data, int|null $length = null): int|false\nBinary safe bzip2 file write',
	'curl_file_create': '(string $filename, string|null $mime_type = null, string|null $posted_filename = null): CURLFile\nCreate a CURLFile object',
	'CURLFile::getFilename': '(): string\nGet file name',
	'CURLFile::getMimeType': '(): string\nGet MIME type',
	'CURLFile::getPostFilename': '(): string\nGet file name for POST',
	'CURLFile::setMimeType': '(string $mime_type): void\nSet MIME type',
	'CURLFile::setPostFilename': '(string $posted_filename): void\nSet file name for POST',
	'curl_close': '(CurlHandle $handle): void\nClose a cURL session',
	'curl_copy_handle': '(CurlHandle $handle): CurlHandle|false\nCopy a cURL handle along with all of its preferences',
	'curl_errno': '(CurlHandle $handle): int\nReturn the last error number',
	'curl_error': '(CurlHandle $handle): string\nReturn a string containing the last error for the current session',
	'curl_escape': '(CurlHandle $handle, string $string): string|false\nURL encodes the given string',
	'curl_exec': '(CurlHandle $handle): string|bool\nPerform a cURL session',
	'curl_getinfo': '(CurlHandle $handle, int|null $option = null): mixed\nGet information regarding a specific transfer',
	'curl_init': '(string|null $url = null): CurlHandle|false\nInitialize a cURL session',
	'curl_multi_add_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nAdd a normal cURL handle to a cURL multi handle',
	'curl_multi_close': '(CurlMultiHandle $multi_handle): void\nRemove all cURL handles from a multi handle',
	'curl_multi_errno': '(CurlMultiHandle $multi_handle): int\nReturn the last multi curl error number',
	'curl_multi_exec': '(CurlMultiHandle $multi_handle, int $still_running): int\nRun the sub-connections of the current cURL handle',
	'curl_multi_getcontent': '(CurlHandle $handle): string|null\nReturn the content of a cURL handle if CURLOPT_RETURNTRANSFER is set',
	'curl_multi_info_read': '(CurlMultiHandle $multi_handle, int $queued_messages = null): array|false\nGet information about the current transfers',
	'curl_multi_init': '(): CurlMultiHandle\nReturns a new cURL multi handle',
	'curl_multi_remove_handle': '(CurlMultiHandle $multi_handle, CurlHandle $handle): int\nRemove a handle from a set of cURL handles',
	'curl_multi_select': '(CurlMultiHandle $multi_handle, float $timeout = 1.0): int\nWait until reading or writing is possible for any cURL multi handle connection',
	'curl_multi_setopt': '(CurlMultiHandle $multi_handle, int $option, mixed $value): bool\nSet a cURL multi option',
	'curl_multi_strerror': '(int $error_code): string|null\nReturn string describing error code',
	'curl_pause': '(CurlHandle $handle, int $flags): int\nPause and unpause a connection',
	'curl_reset': '(CurlHandle $handle): void\nReset all options of a libcurl session handle',
	'curl_setopt_array': '(CurlHandle $handle, array $options): bool\nSet multiple options for a cURL transfer',
	'curl_setopt': '(CurlHandle $handle, int $option, mixed $value): bool\nSet an option for a cURL transfer',
	'curl_share_close': '(CurlShareHandle $share_handle): void\nClose a cURL share handle',
	'curl_share_errno': '(CurlShareHandle $share_handle): int\nReturn the last share curl error number',
	'curl_share_init_persistent': '(array $share_options): CurlSharePersistentHandle\nInitialize a persistent cURL share handle',
	'curl_share_init': '(): CurlShareHandle\nInitialize a cURL share handle',
	'curl_share_setopt': '(CurlShareHandle $share_handle, int $option, mixed $value): bool\nSet an option for a cURL share handle',
	'curl_share_strerror': '(int $error_code): string|null\nReturn string describing the given error code',
	'curl_strerror': '(int $error_code): string|null\nReturn string describing the given error code',
	'curl_unescape': '(CurlHandle $handle, string $string): string|false\nDecodes the given URL encoded string',
	'curl_upkeep': '(CurlHandle $handle): bool\nPerforms any connection upkeep checks',
	'curl_version': '(): array|false\nGets cURL version information',
	'Dom\\Attr::isId': '(): bool\n',
	'Dom\\Attr::rename': '(string|null $namespaceURI, string $qualifiedName): void\nChanges the qualified name or namespace of an attribute',
	'Dom\\CharacterData::after': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\CharacterData::appendData': '(string $data): void\n',
	'Dom\\CharacterData::before': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\CharacterData::deleteData': '(int $offset, int $count): void\n',
	'Dom\\CharacterData::insertData': '(int $offset, string $data): void\n',
	'Dom\\CharacterData::remove': '(): void\n',
	'Dom\\CharacterData::replaceData': '(int $offset, int $count, string $data): void\n',
	'Dom\\CharacterData::replaceWith': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\CharacterData::substringData': '(int $offset, int $count): string\n',
	'Dom\\ChildNode::after': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\ChildNode::before': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\ChildNode::remove': '(): void\n',
	'Dom\\ChildNode::replaceWith': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\HTMLDocument::createEmpty': '(string $encoding = "UTF-8"): Dom\\HTMLDocument\nCreates an empty HTML document',
	'Dom\\HTMLDocument::createFromFile': '(string $path, int $options = ?, string|null $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a file',
	'Dom\\HTMLDocument::createFromString': '(string $source, int $options = ?, string|null $overrideEncoding = null): Dom\\HTMLDocument\nParses an HTML document from a string',
	'Dom\\HTMLDocument::saveHtml': '(Dom\\Node|null $node = null): string\nSerializes the document as an HTML string',
	'Dom\\HTMLDocument::saveHtmlFile': '(string $filename): int|false\nSerializes the document as an HTML file',
	'Dom\\HTMLDocument::saveXml': '(Dom\\Node|null $node = null, int $options = ?): string|false\nSerializes the document as an XML string',
	'Dom\\HTMLDocument::saveXmlFile': '(string $filename, int $options = ?): int|false\nSerializes the document as an XML file',
	'Dom\\ParentNode::append': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\ParentNode::prepend': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\ParentNode::querySelector': '(string $selectors): Dom\\Element|null\nReturns the first element that matches the CSS selectors',
	'Dom\\ParentNode::querySelectorAll': '(string $selectors): Dom\\NodeList\nReturns a collection of elements that match the CSS selectors',
	'Dom\\ParentNode::replaceChildren': '(Dom\\Node|string ...$nodes): void\n',
	'Dom\\Text::splitText': '(int $offset): Dom\\Text\n',
	'Dom\\TokenList::add': '(string ...$tokens): void\nAdds the given tokens to the list',
	'Dom\\TokenList::contains': '(string $token): bool\nReturns whether the list contains a given token',
	'Dom\\TokenList::count': '(): int\nReturns the number of tokens in the list',
	'Dom\\TokenList::getIterator': '(): Iterator\nReturns an iterator over the token list',
	'Dom\\TokenList::item': '(int $index): string|null\nReturns a token from the list',
	'Dom\\TokenList::remove': '(string ...$tokens): void\nRemoves the given tokens from the list',
	'Dom\\TokenList::replace': '(string $token, string $newToken): bool\nReplaces a token in the list with another one',
	'Dom\\TokenList::supports': '(string $token): bool\nReturns whether the given token is supported',
	'Dom\\TokenList::toggle': '(string $token, bool|null $force = null): bool\nToggles the presence of a token in the list',
	'DOMAttr::isId': '(): bool\nChecks if attribute is a defined ID',
	'DOMCharacterData::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the character data',
	'DOMCharacterData::appendData': '(string $data): true\nAppend the string to the end of the character data of the node',
	'DOMCharacterData::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the character data',
	'DOMCharacterData::deleteData': '(int $offset, int $count): bool\nRemove a range of characters from the character data',
	'DOMCharacterData::insertData': '(int $offset, string $data): bool\nInsert a string at the specified UTF-8 codepoint offset',
	'DOMCharacterData::remove': '(): void\nRemoves the character data node',
	'DOMCharacterData::replaceData': '(int $offset, int $count, string $data): bool\nReplace a substring within the character data',
	'DOMCharacterData::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the character data with new nodes',
	'DOMCharacterData::substringData': '(int $offset, int $count): string|false\nExtracts a range of data from the character data',
	'DOMChildNode::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the node',
	'DOMChildNode::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the node',
	'DOMChildNode::remove': '(): void\nRemoves the node',
	'DOMChildNode::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the node with new nodes',
	'DOMDocument::adoptNode': '(DOMNode $node): DOMNode|false\nTransfer a node from another document',
	'DOMDocument::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
	'DOMDocument::createAttribute': '(string $localName): DOMAttr|false\nCreate new attribute',
	'DOMDocument::createAttributeNS': '(string|null $namespace, string $qualifiedName): DOMAttr|false\nCreate new attribute node with an associated namespace',
	'DOMDocument::createCDATASection': '(string $data): DOMCdataSection|false\nCreate new cdata node',
	'DOMDocument::createComment': '(string $data): DOMComment\nCreate new comment node',
	'DOMDocument::createDocumentFragment': '(): DOMDocumentFragment\nCreate new document fragment',
	'DOMDocument::createElement': '(string $localName, string $value = ""): DOMElement|false\nCreate new element node',
	'DOMDocument::createElementNS': '(string|null $namespace, string $qualifiedName, string $value = ""): DOMElement|false\nCreate new element node with an associated namespace',
	'DOMDocument::createEntityReference': '(string $name): DOMEntityReference|false\nCreate new entity reference node',
	'DOMDocument::createProcessingInstruction': '(string $target, string $data = ""): DOMProcessingInstruction|false\nCreates new PI node',
	'DOMDocument::createTextNode': '(string $data): DOMText\nCreate new text node',
	'DOMDocument::getElementById': '(string $elementId): DOMElement|null\nSearches for an element with a certain id',
	'DOMDocument::getElementsByTagName': '(string $qualifiedName): DOMNodeList\nSearches for all elements with given local tag name',
	'DOMDocument::getElementsByTagNameNS': '(string|null $namespace, string $localName): DOMNodeList\nSearches for all elements with given tag name in specified namespace',
	'DOMDocument::importNode': '(DOMNode $node, bool $deep = false): DOMNode|false\nImport node into current document',
	'DOMDocument::load': '(string $filename, int $options = ?): bool\nLoad XML from a file',
	'DOMDocument::loadHTML': '(string $source, int $options = ?): bool\nLoad HTML from a string',
	'DOMDocument::loadHTMLFile': '(string $filename, int $options = ?): bool\nLoad HTML from a file',
	'DOMDocument::loadXML': '(string $source, int $options = ?): bool\nLoad XML from a string',
	'DOMDocument::normalizeDocument': '(): void\nNormalizes the document',
	'DOMDocument::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
	'DOMDocument::registerNodeClass': '(string $baseClass, string|null $extendedClass): true\nRegister extended class used to create base node type',
	'DOMDocument::relaxNGValidate': '(string $filename): bool\nPerforms relaxNG validation on the document',
	'DOMDocument::relaxNGValidateSource': '(string $source): bool\nPerforms relaxNG validation on the document',
	'DOMDocument::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in document',
	'DOMDocument::save': '(string $filename, int $options = ?): int|false\nDumps the internal XML tree back into a file',
	'DOMDocument::saveHTML': '(DOMNode|null $node = null): string|false\nDumps the internal document into a string using HTML formatting',
	'DOMDocument::saveHTMLFile': '(string $filename): int|false\nDumps the internal document into a file using HTML formatting',
	'DOMDocument::saveXML': '(DOMNode|null $node = null, int $options = ?): string|false\nDumps the internal XML tree back into a string',
	'DOMDocument::schemaValidate': '(string $filename, int $flags = ?): bool\nValidates a document based on a schema. Only XML Schema 1.0 is supported.',
	'DOMDocument::schemaValidateSource': '(string $source, int $flags = ?): bool\nValidates a document based on a schema',
	'DOMDocument::validate': '(): bool\nValidates the document based on its DTD',
	'DOMDocument::xinclude': '(int $options = ?): int|false\nSubstitutes XIncludes in a DOMDocument Object',
	'DOMDocumentFragment::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
	'DOMDocumentFragment::appendXML': '(string $data): bool\nAppend raw XML data',
	'DOMDocumentFragment::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
	'DOMDocumentFragment::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in fragment',
	'DOMElement::after': '(DOMNode|string ...$nodes): void\nAdds nodes after the element',
	'DOMElement::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
	'DOMElement::before': '(DOMNode|string ...$nodes): void\nAdds nodes before the element',
	'DOMElement::getAttribute': '(string $qualifiedName): string\nReturns value of attribute',
	'DOMElement::getAttributeNames': '(): array\nGet attribute names',
	'DOMElement::getAttributeNode': '(string $qualifiedName): DOMAttr|DOMNameSpaceNode|false\nReturns attribute node',
	'DOMElement::getAttributeNodeNS': '(string|null $namespace, string $localName): DOMAttr|DOMNameSpaceNode|null\nReturns attribute node',
	'DOMElement::getAttributeNS': '(string|null $namespace, string $localName): string\nReturns value of attribute',
	'DOMElement::getElementsByTagName': '(string $qualifiedName): DOMNodeList\nGets elements by tagname',
	'DOMElement::getElementsByTagNameNS': '(string|null $namespace, string $localName): DOMNodeList\nGet elements by namespaceURI and localName',
	'DOMElement::hasAttribute': '(string $qualifiedName): bool\nChecks to see if attribute exists',
	'DOMElement::hasAttributeNS': '(string|null $namespace, string $localName): bool\nChecks to see if attribute exists',
	'DOMElement::insertAdjacentElement': '(string $where, DOMElement $element): DOMElement|null\nInsert adjacent element',
	'DOMElement::insertAdjacentText': '(string $where, string $data): void\nInsert adjacent text',
	'DOMElement::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
	'DOMElement::remove': '(): void\nRemoves the element',
	'DOMElement::removeAttribute': '(string $qualifiedName): bool\nRemoves attribute',
	'DOMElement::removeAttributeNode': '(DOMAttr $attr): DOMAttr|false\nRemoves attribute',
	'DOMElement::removeAttributeNS': '(string|null $namespace, string $localName): void\nRemoves attribute',
	'DOMElement::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in element',
	'DOMElement::replaceWith': '(DOMNode|string ...$nodes): void\nReplaces the element with new nodes',
	'DOMElement::setAttribute': '(string $qualifiedName, string $value): DOMAttr|bool\nAdds new or modifies existing attribute',
	'DOMElement::setAttributeNode': '(DOMAttr $attr): DOMAttr|null|false\nAdds new attribute node to element',
	'DOMElement::setAttributeNodeNS': '(DOMAttr $attr): DOMAttr|null|false\nAdds new attribute node to element',
	'DOMElement::setAttributeNS': '(string|null $namespace, string $qualifiedName, string $value): void\nAdds new attribute',
	'DOMElement::setIdAttribute': '(string $qualifiedName, bool $isId): void\nDeclares the attribute specified by name to be of type ID',
	'DOMElement::setIdAttributeNode': '(DOMAttr $attr, bool $isId): void\nDeclares the attribute specified by node to be of type ID',
	'DOMElement::setIdAttributeNS': '(string $namespace, string $qualifiedName, bool $isId): void\nDeclares the attribute specified by local name and namespace URI to be of type ID',
	'DOMElement::toggleAttribute': '(string $qualifiedName, bool|null $force = null): bool\nToggle attribute',
	'DOMImplementation::createDocument': '(string|null $namespace = null, string $qualifiedName = "", DOMDocumentType|null $doctype = null): DOMDocument\nCreates a DOMDocument object of the specified type with its document element',
	'DOMImplementation::createDocumentType': '(string $qualifiedName, string $publicId = "", string $systemId = ""): DOMDocumentType|false\nCreates an empty DOMDocumentType object',
	'DOMImplementation::hasFeature': '(string $feature, string $version): bool\nTest if the DOM implementation implements a specific feature',
	'DOMNamedNodeMap::count': '(): int\nGet number of nodes in the map',
	'DOMNamedNodeMap::getIterator': '(): Iterator\nRetrieve an external iterator',
	'DOMNamedNodeMap::getNamedItem': '(string $qualifiedName): DOMNode|null\nRetrieves a node specified by name',
	'DOMNamedNodeMap::getNamedItemNS': '(string|null $namespace, string $localName): DOMNode|null\nRetrieves a node specified by local name and namespace URI',
	'DOMNamedNodeMap::item': '(int $index): DOMNode|null\nRetrieves a node specified by index',
	'DOMNameSpaceNode::__sleep': '(): array\nForbids serialization unless serialization methods are implemented in a subclass',
	'DOMNameSpaceNode::__wakeup': '(): void\nForbids unserialization unless unserialization methods are implemented in a subclass',
	'DOMNode::appendChild': '(DOMNode $node): DOMNode|false\nAdds new child at the end of the children',
	'DOMNode::C14N': '(bool $exclusive = false, bool $withComments = false, array|null $xpath = null, array|null $nsPrefixes = null): string|false\nCanonicalize nodes to a string',
	'DOMNode::C14NFile': '(string $uri, bool $exclusive = false, bool $withComments = false, array|null $xpath = null, array|null $nsPrefixes = null): int|false\nCanonicalize nodes to a file',
	'DOMNode::cloneNode': '(bool $deep = false): DOMNode|false\nClones a node',
	'DOMNode::compareDocumentPosition': '(DOMNode $other): int\nCompares the position of two nodes',
	'DOMNode::contains': '(DOMNode|DOMNameSpaceNode|null $other): bool\nChecks if node contains other node',
	'DOMNode::getLineNo': '(): int\nGet line number for a node',
	'DOMNode::getNodePath': '(): string|null\nGet an XPath for a node',
	'DOMNode::getRootNode': '(array|null $options = null): DOMNode\nGet root node',
	'DOMNode::hasAttributes': '(): bool\nChecks if node has attributes',
	'DOMNode::hasChildNodes': '(): bool\nChecks if node has children',
	'DOMNode::insertBefore': '(DOMNode $node, DOMNode|null $child = null): DOMNode|false\nAdds a new child before a reference node',
	'DOMNode::isDefaultNamespace': '(string $namespace): bool\nChecks if the specified namespaceURI is the default namespace or not',
	'DOMNode::isEqualNode': '(DOMNode|null $otherNode): bool\nChecks that both nodes are equal',
	'DOMNode::isSameNode': '(DOMNode $otherNode): bool\nIndicates if two nodes are the same node',
	'DOMNode::isSupported': '(string $feature, string $version): bool\nChecks if feature is supported for specified version',
	'DOMNode::lookupNamespaceURI': '(string|null $prefix): string|null\nGets the namespace URI of the node based on the prefix',
	'DOMNode::lookupPrefix': '(string $namespace): string|null\nGets the namespace prefix of the node based on the namespace URI',
	'DOMNode::normalize': '(): void\nNormalizes the node',
	'DOMNode::removeChild': '(DOMNode $child): DOMNode|false\nRemoves child from list of children',
	'DOMNode::replaceChild': '(DOMNode $node, DOMNode $child): DOMNode|false\nReplaces a child',
	'DOMNode::__sleep': '(): array\nForbids serialization unless serialization methods are implemented in a subclass',
	'DOMNode::__wakeup': '(): void\nForbids unserialization unless unserialization methods are implemented in a subclass',
	'DOMNodeList::count': '(): int\nGet number of nodes in the list',
	'DOMNodeList::getIterator': '(): Iterator\nRetrieve an external iterator',
	'DOMNodeList::item': '(int $index): DOMElement|DOMNode|DOMNameSpaceNode|null\nRetrieves a node specified by index',
	'DOMParentNode::append': '(DOMNode|string ...$nodes): void\nAppends nodes after the last child node',
	'DOMParentNode::prepend': '(DOMNode|string ...$nodes): void\nPrepends nodes before the first child node',
	'DOMParentNode::replaceChildren': '(DOMNode|string ...$nodes): void\nReplace children in node',
	'DOMText::isElementContentWhitespace': '(): bool\nReturns whether this text node contains whitespace in element content',
	'DOMText::isWhitespaceInElementContent': '(): bool\nIndicates whether this text node contains whitespace',
	'DOMText::splitText': '(int $offset): DOMText|false\nBreaks this node into two nodes at the specified offset',
	'DOMXPath::evaluate': '(string $expression, DOMNode|null $contextNode = null, bool $registerNodeNS = true): mixed\nEvaluates the given XPath expression and returns a typed result if possible',
	'DOMXPath::query': '(string $expression, DOMNode|null $contextNode = null, bool $registerNodeNS = true): mixed\nEvaluates the given XPath expression',
	'DOMXPath::quote': '(string $str): string\nQuotes a string for use in an XPath expression',
	'DOMXPath::registerNamespace': '(string $prefix, string $namespace): bool\nRegisters the namespace with the DOMXPath object',
	'DOMXPath::registerPhpFunctionNS': '(string $namespaceURI, string $name, callable $callable): void\nRegister a PHP functions as namespaced XPath function',
	'DOMXPath::registerPhpFunctions': '(string|array|null $restrict = null): void\nRegister PHP functions as XPath functions',
	'dom_import_simplexml': '(object $node): DOMAttr|DOMElement\nGets a DOMAttr or DOMElement object from a SimpleXMLElement object',
	'Dom\\import_simplexml': '(object $node): Dom\\Attr|Dom\\Element\nGets a Dom\\Attr or Dom\\Element object from a SimpleXMLElement object',
	'enchant_broker_describe': '(EnchantBroker $broker): array\nEnumerates the Enchant providers',
	'enchant_broker_dict_exists': '(EnchantBroker $broker, string $tag): bool\nWhether a dictionary exists or not. Using non-empty tag',
	'enchant_broker_free_dict': '(EnchantDictionary $dictionary): bool\nFree a dictionary resource',
	'enchant_broker_free': '(EnchantBroker $broker): bool\nFree the broker resource and its dictionaries',
	'enchant_broker_get_dict_path': '(EnchantBroker $broker, int $type): string|false\nGet the directory path for a given backend',
	'enchant_broker_get_error': '(EnchantBroker $broker): string|false\nReturns the last error of the broker',
	'enchant_broker_init': '(): EnchantBroker|false\nCreate a new broker object capable of requesting',
	'enchant_broker_list_dicts': '(EnchantBroker $broker): array\nReturns a list of available dictionaries',
	'enchant_broker_request_dict': '(EnchantBroker $broker, string $tag): EnchantDictionary|false\nCreate a new dictionary using a tag',
	'enchant_broker_request_pwl_dict': '(EnchantBroker $broker, string $filename): EnchantDictionary|false\nCreates a dictionary using a PWL file',
	'enchant_broker_set_dict_path': '(EnchantBroker $broker, int $type, string $path): bool\nSet the directory path for a given backend',
	'enchant_broker_set_ordering': '(EnchantBroker $broker, string $tag, string $ordering): bool\nDeclares a preference of dictionaries to use for the language',
	'enchant_dict_add_to_personal': 'Alias of enchant_dict_add',
	'enchant_dict_add_to_session': '(EnchantDictionary $dictionary, string $word): void\nAdd \'word\' to this spell-checking session',
	'enchant_dict_add': '(EnchantDictionary $dictionary, string $word): void\nAdd a word to personal word list',
	'enchant_dict_check': '(EnchantDictionary $dictionary, string $word): bool\nCheck whether a word is correctly spelled or not',
	'enchant_dict_describe': '(EnchantDictionary $dictionary): array\nDescribes an individual dictionary',
	'enchant_dict_get_error': '(EnchantDictionary $dictionary): string|false\nReturns the last error of the current spelling-session',
	'enchant_dict_is_added': '(EnchantDictionary $dictionary, string $word): bool\nWhether or not \'word\' exists in this spelling-session',
	'enchant_dict_is_in_session': 'Alias of enchant_dict_is_added',
	'enchant_dict_quick_check': '(EnchantDictionary $dictionary, string $word, array $suggestions = null): bool\nCheck the word is correctly spelled and provide suggestions',
	'enchant_dict_store_replacement': '(EnchantDictionary $dictionary, string $misspelled, string $correct): void\nAdd a correction for a word',
	'enchant_dict_suggest': '(EnchantDictionary $dictionary, string $word): array\nWill return a list of values if any of those pre-conditions are not met',
	'_': 'Alias of gettext',
	'bind_textdomain_codeset': '(string $domain, string|null $codeset = null): string|false\nSpecify or get the character encoding in which the messages from the DOMAIN message catalog will be returned',
	'bindtextdomain': '(string $domain, string|null $directory = null): string|false\nSets or gets the path for a domain',
	'dcgettext': '(string $domain, string $message, int $category): string\nOverrides the domain for a single lookup',
	'dcngettext': '(string $domain, string $singular, string $plural, int $count, int $category): string\nPlural version of dcgettext',
	'dgettext': '(string $domain, string $message): string\nOverride the current domain',
	'dngettext': '(string $domain, string $singular, string $plural, int $count): string\nPlural version of dgettext',
	'gettext': '(string $message): string\nLookup a message in the current domain',
	'ngettext': '(string $singular, string $plural, int $count): string\nPlural version of gettext',
	'textdomain': '(string|null $domain = null): string\nSets the default domain',
	'gmp_abs': '(GMP|int|string $num): GMP\nAbsolute value',
	'gmp_add': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nAdd numbers',
	'gmp_and': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise AND',
	'gmp_binomial': '(GMP|int|string $n, int $k): GMP\nCalculates binomial coefficient',
	'gmp_clrbit': '(GMP $num, int $index): void\nClear bit',
	'gmp_cmp': '(GMP|int|string $num1, GMP|int|string $num2): int\nCompare numbers',
	'gmp_com': '(GMP|int|string $num): GMP\nCalculates one\'s complement',
	'gmp_div_q': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nDivide numbers',
	'gmp_div_qr': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): array\nDivide numbers and get quotient and remainder',
	'gmp_div_r': '(GMP|int|string $num1, GMP|int|string $num2, int $rounding_mode = GMP_ROUND_ZERO): GMP\nRemainder of the division of numbers',
	'gmp_div': 'Alias of gmp_div_q',
	'gmp_divexact': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nExact division of numbers',
	'gmp_export': '(GMP|int|string $num, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): string\nExport to a binary string',
	'gmp_fact': '(GMP|int|string $num): GMP\nFactorial',
	'gmp_gcd': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate GCD',
	'gmp_gcdext': '(GMP|int|string $num1, GMP|int|string $num2): array\nCalculate GCD and multipliers',
	'gmp_hamdist': '(GMP|int|string $num1, GMP|int|string $num2): int\nHamming distance',
	'gmp_import': '(string $data, int $word_size = 1, int $flags = GMP_MSW_FIRST | GMP_NATIVE_ENDIAN): GMP\nImport from a binary string',
	'gmp_init': '(int|string $num, int $base = ?): GMP\nCreate GMP number',
	'gmp_intval': '(GMP|int|string $num): int\nConvert GMP number to integer',
	'gmp_invert': '(GMP|int|string $num1, GMP|int|string $num2): GMP|false\nInverse by modulo',
	'gmp_jacobi': '(GMP|int|string $num1, GMP|int|string $num2): int\nJacobi symbol',
	'gmp_kronecker': '(GMP|int|string $num1, GMP|int|string $num2): int\nKronecker symbol',
	'gmp_lcm': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nCalculate LCM',
	'gmp_legendre': '(GMP|int|string $num1, GMP|int|string $num2): int\nLegendre symbol',
	'gmp_mod': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nModulo operation',
	'gmp_mul': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nMultiply numbers',
	'gmp_neg': '(GMP|int|string $num): GMP\nNegate number',
	'gmp_nextprime': '(GMP|int|string $num): GMP\nFind next prime number',
	'gmp_or': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise OR',
	'gmp_perfect_power': '(GMP|int|string $num): bool\nPerfect power check',
	'gmp_perfect_square': '(GMP|int|string $num): bool\nPerfect square check',
	'gmp_popcount': '(GMP|int|string $num): int\nPopulation count',
	'gmp_pow': '(GMP|int|string $num, int $exponent): GMP\nRaise number into power',
	'gmp_powm': '(GMP|int|string $num, GMP|int|string $exponent, GMP|int|string $modulus): GMP\nRaise number into power with modulo',
	'gmp_prob_prime': '(GMP|int|string $num, int $repetitions = 10): int\nCheck if number is "probably prime"',
	'gmp_random_bits': '(int $bits): GMP\nRandom number',
	'gmp_random_range': '(GMP|int|string $min, GMP|int|string $max): GMP\nGet a uniformly selected integer',
	'gmp_random_seed': '(GMP|int|string $seed): void\nSets the RNG seed',
	'gmp_random': '(int $limiter = 20): GMP\nRandom number',
	'gmp_root': '(GMP|int|string $num, int $nth): GMP\nTake the integer part of nth root',
	'gmp_rootrem': '(GMP|int|string $num, int $nth): array\nTake the integer part and remainder of nth root',
	'gmp_scan0': '(GMP|int|string $num1, int $start): int\nScan for 0',
	'gmp_scan1': '(GMP|int|string $num1, int $start): int\nScan for 1',
	'gmp_setbit': '(GMP $num, int $index, bool $value = true): void\nSet bit',
	'gmp_sign': '(GMP|int|string $num): int\nSign of number',
	'gmp_sqrt': '(GMP|int|string $num): GMP\nCalculate square root',
	'gmp_sqrtrem': '(GMP|int|string $num): array\nSquare root with remainder',
	'gmp_strval': '(GMP|int|string $num, int $base = 10): string\nConvert GMP number to string',
	'gmp_sub': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nSubtract numbers',
	'gmp_testbit': '(GMP|int|string $num, int $index): bool\nTests if a bit is set',
	'gmp_xor': '(GMP|int|string $num1, GMP|int|string $num2): GMP\nBitwise XOR',
	'GMP::__serialize': '(): array\nSerializes the GMP object',
	'GMP::__unserialize': '(array $data): void\nDeserializes the $data parameter into a GMP object',
	'ldap_8859_to_t61': '(string $value): string|false\nTranslate 8859 characters to t61 characters',
	'ldap_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nAdd entries to LDAP directory',
	'ldap_add': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nAdd entries to LDAP directory',
	'ldap_bind_ext': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null, array|null $controls = null): LDAP\\Result|false\nBind to LDAP directory',
	'ldap_bind': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null): bool\nBind to LDAP directory',
	'ldap_close': 'Alias of ldap_unbind',
	'ldap_compare': '(LDAP\\Connection $ldap, string $dn, string $attribute, string $value, array|null $controls = null): bool|int\nCompare value of attribute found in entry specified with DN',
	'ldap_connect_wallet': '(string|null $uri = null, string $wallet, string $password, int $auth_mode = GSLC_SSL_NO_AUTH): LDAP\\Connection|false\nConnect to an LDAP server',
	'ldap_connect': '(string|null $uri = null): LDAP\\Connection|false\nConnect to an LDAP server',
	'ldap_connect': '(string|null $host = null, int $port = 389): LDAP\\Connection|false\nConnect to an LDAP server',
	'ldap_control_paged_result_response': '(resource $link, resource $result, string $cookie = ?, int $estimated = ?): bool\nRetrieve the LDAP pagination cookie',
	'ldap_control_paged_result': '(resource $link, int $pagesize, bool $iscritical = false, string $cookie = ""): bool\nSend LDAP pagination control',
	'ldap_count_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCount the number of entries in a search',
	'ldap_count_references': '(LDAP\\Connection $ldap, LDAP\\Result $result): int\nCounts the number of references in a search result',
	'ldap_delete_ext': '(LDAP\\Connection $ldap, string $dn, array|null $controls = null): LDAP\\Result|false\nDelete an entry from a directory',
	'ldap_delete': '(LDAP\\Connection $ldap, string $dn, array|null $controls = null): bool\nDelete an entry from a directory',
	'ldap_dn2ufn': '(string $dn): string|false\nConvert DN to User Friendly Naming format',
	'ldap_err2str': '(int $errno): string\nConvert LDAP error number into string error message',
	'ldap_errno': '(LDAP\\Connection $ldap): int\nReturn the LDAP error number of the last LDAP command',
	'ldap_error': '(LDAP\\Connection $ldap): string\nReturn the LDAP error message of the last LDAP command',
	'ldap_escape': '(string $value, string $ignore = "", int $flags = ?): string\nEscape a string for use in an LDAP filter or DN',
	'ldap_exop_passwd': '(LDAP\\Connection $ldap, string $user = "", string $old_password = "", string $new_password = "", array $controls = null): string|bool\nPASSWD extended operation helper',
	'ldap_exop_refresh': '(LDAP\\Connection $ldap, string $dn, int $ttl): int|false\nRefresh extended operation helper',
	'ldap_exop_sync': '(LDAP\\Connection $ldap, string $request_oid, string|null $request_data = null, array|null $controls = null, string $response_data = null, string $response_oid = null): LDAP\\Result|bool\nPerforms an extended operation',
	'ldap_exop_whoami': '(LDAP\\Connection $ldap): string|false\nWHOAMI extended operation helper',
	'ldap_exop': '(LDAP\\Connection $ldap, string $request_oid, string $request_data = null, array $controls = null, string $response_data = ?, string $response_oid = ?): mixed\nPerforms an extended operation',
	'ldap_explode_dn': '(string $dn, int $with_attrib): array|false\nSplits DN into its component parts',
	'ldap_first_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nReturn first attribute',
	'ldap_first_entry': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first result id',
	'ldap_first_reference': '(LDAP\\Connection $ldap, LDAP\\Result $result): LDAP\\ResultEntry|false\nReturn first reference',
	'ldap_free_result': '(LDAP\\Result $result): bool\nFree result memory',
	'ldap_get_attributes': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): array\nGet attributes from a search result entry',
	'ldap_get_dn': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the DN of a result entry',
	'ldap_get_entries': '(LDAP\\Connection $ldap, LDAP\\Result $result): array|false\nGet all result entries',
	'ldap_get_option': '(LDAP\\Connection $ldap, int $option, array|string|int $value = null): bool\nGet the current value for given option',
	'ldap_get_values_len': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all binary values from a result entry',
	'ldap_get_values': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, string $attribute): array|false\nGet all values from a result entry',
	'ldap_list': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nSingle-level search',
	'ldap_mod_add_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nAdd attribute values to current attributes',
	'ldap_mod_add': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nAdd attribute values to current attributes',
	'ldap_mod_del_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nDelete attribute values from current attributes',
	'ldap_mod_del': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nDelete attribute values from current attributes',
	'ldap_mod_replace_ext': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): LDAP\\Result|false\nReplace attribute values with new ones',
	'ldap_mod_replace': '(LDAP\\Connection $ldap, string $dn, array $entry, array|null $controls = null): bool\nReplace attribute values with new ones',
	'ldap_modify_batch': '(LDAP\\Connection $ldap, string $dn, array $modifications_info, array|null $controls = null): bool\nBatch and execute modifications on an LDAP entry',
	'ldap_modify': 'Alias of ldap_mod_replace',
	'ldap_next_attribute': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): string|false\nGet the next attribute in result',
	'ldap_next_entry': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next result entry',
	'ldap_next_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry): LDAP\\ResultEntry|false\nGet next reference',
	'ldap_parse_exop': '(LDAP\\Connection $ldap, LDAP\\Result $result, string $response_data = null, string $response_oid = null): bool\nParse result object from an LDAP extended operation',
	'ldap_parse_reference': '(LDAP\\Connection $ldap, LDAP\\ResultEntry $entry, array $referrals): bool\nExtract information from reference entry',
	'ldap_parse_result': '(LDAP\\Connection $ldap, LDAP\\Result $result, int $error_code, string $matched_dn = null, string $error_message = null, array $referrals = null, array $controls = null): bool\nExtract information from result',
	'ldap_read': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nRead an entry',
	'ldap_rename_ext': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, array|null $controls = null): LDAP\\Result|false\nModify the name of an entry',
	'ldap_rename': '(LDAP\\Connection $ldap, string $dn, string $new_rdn, string $new_parent, bool $delete_old_rdn, array|null $controls = null): bool\nModify the name of an entry',
	'ldap_sasl_bind': '(LDAP\\Connection $ldap, string|null $dn = null, string|null $password = null, string|null $mech = null, string|null $realm = null, string|null $authc_id = null, string|null $authz_id = null, string|null $props = null): bool\nBind to LDAP directory using SASL',
	'ldap_search': '(LDAP\\Connection|array $ldap, array|string $base, array|string $filter, array $attributes = [], int $attributes_only = ?, int $sizelimit = -1, int $timelimit = -1, int $deref = LDAP_DEREF_NEVER, array|null $controls = null): LDAP\\Result|array|false\nSearch LDAP tree',
	'ldap_set_option': '(LDAP\\Connection|null $ldap, int $option, array|string|int|bool $value): bool\nSet the value of the given option',
	'ldap_set_rebind_proc': '(LDAP\\Connection $ldap, callable|null $callback): bool\nSet a callback function to do re-binds on referral chasing',
	'ldap_sort': '(resource $link, resource $result, string $sortfilter): bool\nSort LDAP result entries on the client side',
	'ldap_start_tls': '(LDAP\\Connection $ldap): bool\nStart TLS',
	'ldap_t61_to_8859': '(string $value): string|false\nTranslate t61 characters to 8859 characters',
	'ldap_unbind': '(LDAP\\Connection $ldap): bool\nUnbind from LDAP directory',
	'libxml_clear_errors': '(): void\nClear libxml error buffer',
	'libxml_disable_entity_loader': '(bool $disable = true): bool\nDisable the ability to load external entities',
	'libxml_get_errors': '(): array\nRetrieve array of errors',
	'libxml_get_external_entity_loader': '(): callable|null\nGet the current external entity loader',
	'libxml_get_last_error': '(): LibXMLError|false\nRetrieve last error from libxml',
	'libxml_set_external_entity_loader': '(callable|null $resolver_function): bool\nChanges the default external entity loader',
	'libxml_set_streams_context': '(resource $context): void\nSet the streams context for the next libxml document load or write',
	'libxml_use_internal_errors': '(bool|null $use_errors = null): bool\nDisable libxml errors and allow user to fetch error information as needed',
	'mysqli_connect': 'Alias of mysqli::__construct',
	'mysqli::escape_string': 'Alias of mysqli_real_escape_string',
	'mysqli_execute': 'Alias of mysqli_stmt_execute',
	'mysqli_get_client_stats': '(): array\nReturns client per-process statistics',
	'mysqli_get_links_stats': '(): array\nReturn information about open and cached links',
	'mysqli_report': 'Alias of mysqli_driver->report_mode',
	'mysqli::set_opt': 'Alias of mysqli_options',
	'mysqli_affected_rows': '(mysqli $mysql): int|string\nGets the number of affected rows in a previous MySQL operation',
	'mysqli::autocommit': '(bool $enable): bool\nTurns on or off auto-committing database modifications',
	'mysqli_autocommit': '(mysqli $mysql, bool $enable): bool\nTurns on or off auto-committing database modifications',
	'mysqli::begin_transaction': '(int $flags = ?, string|null $name = null): bool\nStarts a transaction',
	'mysqli_begin_transaction': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nStarts a transaction',
	'mysqli::change_user': '(string $username, string $password, string|null $database): bool\nChanges the user of the database connection',
	'mysqli_change_user': '(mysqli $mysql, string $username, string $password, string|null $database): bool\nChanges the user of the database connection',
	'mysqli::character_set_name': '(): string\nReturns the current character set of the database connection',
	'mysqli_character_set_name': '(mysqli $mysql): string\nReturns the current character set of the database connection',
	'mysqli::close': '(): true\nCloses a previously opened database connection',
	'mysqli_close': '(mysqli $mysql): true\nCloses a previously opened database connection',
	'mysqli::commit': '(int $flags = ?, string|null $name = null): bool\nCommits the current transaction',
	'mysqli_commit': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nCommits the current transaction',
	'mysqli_connect_errno': '(): int\nReturns the error code from last connect call',
	'mysqli_connect_error': '(): string|null\nReturns a description of the last connection error',
	'mysqli::connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null): bool\nOpen a new connection to the MySQL server',
	'mysqli_connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null): mysqli|false\nOpen a new connection to the MySQL server',
	'mysqli::debug': '(string $options): true\nPerforms debugging operations',
	'mysqli_debug': '(string $options): true\nPerforms debugging operations',
	'mysqli::dump_debug_info': '(): bool\nDump debugging information into the log',
	'mysqli_dump_debug_info': '(mysqli $mysql): bool\nDump debugging information into the log',
	'mysqli_errno': '(mysqli $mysql): int\nReturns the error code for the most recent function call',
	'mysqli_error_list': '(mysqli $mysql): array\nReturns a list of errors from the last command executed',
	'mysqli_error': '(mysqli $mysql): string\nReturns a string description of the last error',
	'mysqli::execute_query': '(string $query, array|null $params = null): mysqli_result|bool\nPrepares, binds parameters, and executes SQL statement',
	'mysqli_execute_query': '(mysqli $mysql, string $query, array|null $params = null): mysqli_result|bool\nPrepares, binds parameters, and executes SQL statement',
	'mysqli_field_count': '(mysqli $mysql): int\nReturns the number of columns for the most recent query',
	'mysqli::get_charset': '(): object|null\nReturns a character set object',
	'mysqli_get_charset': '(mysqli $mysql): object|null\nReturns a character set object',
	'mysqli::get_client_info': '(): string\nGet MySQL client info',
	'mysqli_get_client_info': '(mysqli|null $mysql = null): string\nGet MySQL client info',
	'mysqli_get_client_version': '(): int\nReturns the MySQL client version as an integer',
	'mysqli::get_connection_stats': '(): array\nReturns statistics about the client connection',
	'mysqli_get_connection_stats': '(mysqli $mysql): array\nReturns statistics about the client connection',
	'mysqli_get_host_info': '(mysqli $mysql): string\nReturns a string representing the type of connection used',
	'mysqli_get_proto_info': '(mysqli $mysql): int\nReturns the version of the MySQL protocol used',
	'mysqli::get_server_info': '(): string\nReturns the version of the MySQL server',
	'mysqli_get_server_info': '(mysqli $mysql): string\nReturns the version of the MySQL server',
	'mysqli_get_server_version': '(mysqli $mysql): int\nReturns the version of the MySQL server as an integer',
	'mysqli::get_warnings': '(): mysqli_warning|false\nGet result of SHOW WARNINGS',
	'mysqli_get_warnings': '(mysqli $mysql): mysqli_warning|false\nGet result of SHOW WARNINGS',
	'mysqli_info': '(mysqli $mysql): string|null\nRetrieves information about the most recently executed query',
	'mysqli::init': '(): bool|null\nInitializes MySQLi and returns an object for use with mysqli_real_connect()',
	'mysqli_init': '(): mysqli|false\nInitializes MySQLi and returns an object for use with mysqli_real_connect()',
	'mysqli_insert_id': '(mysqli $mysql): int|string\nReturns the value generated for an AUTO_INCREMENT column by the last query',
	'mysqli::kill': '(int $process_id): bool\nAsks the server to kill a MySQL thread',
	'mysqli_kill': '(mysqli $mysql, int $process_id): bool\nAsks the server to kill a MySQL thread',
	'mysqli::more_results': '(): bool\nCheck if there are any more query results from a multi query',
	'mysqli_more_results': '(mysqli $mysql): bool\nCheck if there are any more query results from a multi query',
	'mysqli::multi_query': '(string $query): bool\nPerforms one or more queries on the database',
	'mysqli_multi_query': '(mysqli $mysql, string $query): bool\nPerforms one or more queries on the database',
	'mysqli::next_result': '(): bool\nPrepare next result from multi_query',
	'mysqli_next_result': '(mysqli $mysql): bool\nPrepare next result from multi_query',
	'mysqli::options': '(int $option, string|int $value): bool\nSet options',
	'mysqli_options': '(mysqli $mysql, int $option, string|int $value): bool\nSet options',
	'mysqli::ping': '(): bool\nPings a server connection, or tries to reconnect if the connection has gone down',
	'mysqli_ping': '(mysqli $mysql): bool\nPings a server connection, or tries to reconnect if the connection has gone down',
	'mysqli::poll': '(array|null $read, array|null $error, array $reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
	'mysqli_poll': '(array|null $read, array|null $error, array $reject, int $seconds, int $microseconds = ?): int|false\nPoll connections',
	'mysqli::prepare': '(string $query): mysqli_stmt|false\nPrepares an SQL statement for execution',
	'mysqli_prepare': '(mysqli $mysql, string $query): mysqli_stmt|false\nPrepares an SQL statement for execution',
	'mysqli::query': '(string $query, int $result_mode = MYSQLI_STORE_RESULT): mysqli_result|bool\nPerforms a query on the database',
	'mysqli_query': '(mysqli $mysql, string $query, int $result_mode = MYSQLI_STORE_RESULT): mysqli_result|bool\nPerforms a query on the database',
	'mysqli::real_connect': '(string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null, int $flags = ?): bool\nOpens a connection to a mysql server',
	'mysqli_real_connect': '(mysqli $mysql, string|null $hostname = null, string|null $username = null, string|null $password = null, string|null $database = null, int|null $port = null, string|null $socket = null, int $flags = ?): bool\nOpens a connection to a mysql server',
	'mysqli::real_escape_string': '(string $string): string\nEscapes special characters in a string for use in an SQL statement, taking into account the current charset of the connection',
	'mysqli_real_escape_string': '(mysqli $mysql, string $string): string\nEscapes special characters in a string for use in an SQL statement, taking into account the current charset of the connection',
	'mysqli::real_query': '(string $query): bool\nExecute an SQL query',
	'mysqli_real_query': '(mysqli $mysql, string $query): bool\nExecute an SQL query',
	'mysqli::reap_async_query': '(): mysqli_result|bool\nGet result from async query',
	'mysqli_reap_async_query': '(mysqli $mysql): mysqli_result|bool\nGet result from async query',
	'mysqli::refresh': '(int $flags): bool\nRefreshes',
	'mysqli_refresh': '(mysqli $mysql, int $flags): bool\nRefreshes',
	'mysqli::release_savepoint': '(string $name): bool\nRemoves the named savepoint from the set of savepoints of the current transaction',
	'mysqli_release_savepoint': '(mysqli $mysql, string $name): bool\nRemoves the named savepoint from the set of savepoints of the current transaction',
	'mysqli::rollback': '(int $flags = ?, string|null $name = null): bool\nRolls back current transaction',
	'mysqli_rollback': '(mysqli $mysql, int $flags = ?, string|null $name = null): bool\nRolls back current transaction',
	'mysqli::savepoint': '(string $name): bool\nSet a named transaction savepoint',
	'mysqli_savepoint': '(mysqli $mysql, string $name): bool\nSet a named transaction savepoint',
	'mysqli::select_db': '(string $database): bool\nSelects the default database for database queries',
	'mysqli_select_db': '(mysqli $mysql, string $database): bool\nSelects the default database for database queries',
	'mysqli::set_charset': '(string $charset): bool\nSets the client character set',
	'mysqli_set_charset': '(mysqli $mysql, string $charset): bool\nSets the client character set',
	'mysqli_sqlstate': '(mysqli $mysql): string\nReturns the SQLSTATE error from previous MySQL operation',
	'mysqli::ssl_set': '(string|null $key, string|null $certificate, string|null $ca_certificate, string|null $ca_path, string|null $cipher_algos): true\nUsed for establishing secure connections using SSL',
	'mysqli_ssl_set': '(mysqli $mysql, string|null $key, string|null $certificate, string|null $ca_certificate, string|null $ca_path, string|null $cipher_algos): true\nUsed for establishing secure connections using SSL',
	'mysqli::stat': '(): string|false\nGets the current system status',
	'mysqli_stat': '(mysqli $mysql): string|false\nGets the current system status',
	'mysqli::stmt_init': '(): mysqli_stmt|false\nInitializes a statement and returns an object for use with mysqli_stmt_prepare',
	'mysqli_stmt_init': '(mysqli $mysql): mysqli_stmt|false\nInitializes a statement and returns an object for use with mysqli_stmt_prepare',
	'mysqli::store_result': '(int $mode = ?): mysqli_result|false\nTransfers a result set from the last query',
	'mysqli_store_result': '(mysqli $mysql, int $mode = ?): mysqli_result|false\nTransfers a result set from the last query',
	'mysqli_thread_id': '(mysqli $mysql): int\nReturns the thread ID for the current connection',
	'mysqli::thread_safe': '(): bool\nReturns whether thread safety is given or not',
	'mysqli_thread_safe': '(): bool\nReturns whether thread safety is given or not',
	'mysqli::use_result': '(): mysqli_result|false\nInitiate a result set retrieval',
	'mysqli_use_result': '(mysqli $mysql): mysqli_result|false\nInitiate a result set retrieval',
	'mysqli_warning_count': '(mysqli $mysql): int\nReturns the number of warnings generated by the most recently executed query',
	'mysqli_driver::embedded_server_end': '(): void\nStop embedded server',
	'mysqli_embedded_server_end': '(): void\nStop embedded server',
	'mysqli_driver::embedded_server_start': '(int $start, array $arguments, array $groups): bool\nInitialize and start embedded server',
	'mysqli_embedded_server_start': '(int $start, array $arguments, array $groups): bool\nInitialize and start embedded server',
	'mysqli_report': '(int $flags): true\nSets mysqli error reporting mode',
	'mysqli_field_tell': '(mysqli_result $result): int\nGet current field offset of a result pointer',
	'mysqli_result::data_seek': '(int $offset): bool\nAdjusts the result pointer to an arbitrary row in the result',
	'mysqli_data_seek': '(mysqli_result $result, int $offset): bool\nAdjusts the result pointer to an arbitrary row in the result',
	'mysqli_result::fetch_all': '(int $mode = MYSQLI_NUM): array\nFetch all result rows as an associative array, a numeric array, or both',
	'mysqli_fetch_all': '(mysqli_result $result, int $mode = MYSQLI_NUM): array\nFetch all result rows as an associative array, a numeric array, or both',
	'mysqli_result::fetch_array': '(int $mode = MYSQLI_BOTH): array|null|false\nFetch the next row of a result set as an associative, a numeric array, or both',
	'mysqli_fetch_array': '(mysqli_result $result, int $mode = MYSQLI_BOTH): array|null|false\nFetch the next row of a result set as an associative, a numeric array, or both',
	'mysqli_result::fetch_assoc': '(): array|null|false\nFetch the next row of a result set as an associative array',
	'mysqli_fetch_assoc': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an associative array',
	'mysqli_result::fetch_column': '(int $column = ?): null|int|float|string|false\nFetch a single column from the next row of a result set',
	'mysqli_fetch_column': '(mysqli_result $result, int $column = ?): null|int|float|string|false\nFetch a single column from the next row of a result set',
	'mysqli_result::fetch_field_direct': '(int $index): object|false\nFetch meta-data for a single field',
	'mysqli_fetch_field_direct': '(mysqli_result $result, int $index): object|false\nFetch meta-data for a single field',
	'mysqli_result::fetch_field': '(): object|false\nReturns the next field in the result set',
	'mysqli_fetch_field': '(mysqli_result $result): object|false\nReturns the next field in the result set',
	'mysqli_result::fetch_fields': '(): array\nReturns an array of objects representing the fields in a result set',
	'mysqli_fetch_fields': '(mysqli_result $result): array\nReturns an array of objects representing the fields in a result set',
	'mysqli_result::fetch_object': '(string $class = "stdClass", array $constructor_args = []): object|null|false\nFetch the next row of a result set as an object',
	'mysqli_fetch_object': '(mysqli_result $result, string $class = "stdClass", array $constructor_args = []): object|null|false\nFetch the next row of a result set as an object',
	'mysqli_result::fetch_row': '(): array|null|false\nFetch the next row of a result set as an enumerated array',
	'mysqli_fetch_row': '(mysqli_result $result): array|null|false\nFetch the next row of a result set as an enumerated array',
	'mysqli_num_fields': '(mysqli_result $result): int\nGets the number of fields in the result set',
	'mysqli_result::field_seek': '(int $index): true\nSet result pointer to a specified field offset',
	'mysqli_field_seek': '(mysqli_result $result, int $index): true\nSet result pointer to a specified field offset',
	'mysqli_result::free': '(): void\nFrees the memory associated with a result',
	'mysqli_result::close': '(): void\nFrees the memory associated with a result',
	'mysqli_result::free_result': '(): void\nFrees the memory associated with a result',
	'mysqli_free_result': '(mysqli_result $result): void\nFrees the memory associated with a result',
	'mysqli_result::getIterator': '(): Iterator\nRetrieve an external iterator',
	'mysqli_fetch_lengths': '(mysqli_result $result): array|false\nReturns the lengths of the columns of the current row in the result set',
	'mysqli_num_rows': '(mysqli_result $result): int|string\nGets the number of rows in the result set',
	'mysqli_sql_exception::getSqlState': '(): string\nReturns the SQLSTATE error code',
	'mysqli_stmt_affected_rows': '(mysqli_stmt $statement): int|string\nReturns the total number of rows changed, deleted, inserted, or matched by the last statement executed',
	'mysqli_stmt::attr_get': '(int $attribute): int\nUsed to get the current value of a statement attribute',
	'mysqli_stmt_attr_get': '(mysqli_stmt $statement, int $attribute): int\nUsed to get the current value of a statement attribute',
	'mysqli_stmt::attr_set': '(int $attribute, int $value): bool\nUsed to modify the behavior of a prepared statement',
	'mysqli_stmt_attr_set': '(mysqli_stmt $statement, int $attribute, int $value): bool\nUsed to modify the behavior of a prepared statement',
	'mysqli_stmt::bind_param': '(string $types, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement as parameters',
	'mysqli_stmt_bind_param': '(mysqli_stmt $statement, string $types, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement as parameters',
	'mysqli_stmt::bind_result': '(mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement for result storage',
	'mysqli_stmt_bind_result': '(mysqli_stmt $statement, mixed $var, mixed ...$vars): bool\nBinds variables to a prepared statement for result storage',
	'mysqli_stmt::close': '(): true\nCloses a prepared statement',
	'mysqli_stmt_close': '(mysqli_stmt $statement): true\nCloses a prepared statement',
	'mysqli_stmt::data_seek': '(int $offset): void\nAdjusts the result pointer to an arbitrary row in the buffered result',
	'mysqli_stmt_data_seek': '(mysqli_stmt $statement, int $offset): void\nAdjusts the result pointer to an arbitrary row in the buffered result',
	'mysqli_stmt_errno': '(mysqli_stmt $statement): int\nReturns the error code for the most recent statement call',
	'mysqli_stmt_error_list': '(mysqli_stmt $statement): array\nReturns a list of errors from the last statement executed',
	'mysqli_stmt_error': '(mysqli_stmt $statement): string\nReturns a string description for last statement error',
	'mysqli_stmt::execute': '(array|null $params = null): bool\nExecutes a prepared statement',
	'mysqli_stmt_execute': '(mysqli_stmt $statement, array|null $params = null): bool\nExecutes a prepared statement',
	'mysqli_stmt::fetch': '(): bool|null\nFetch results from a prepared statement into the bound variables',
	'mysqli_stmt_fetch': '(mysqli_stmt $statement): bool|null\nFetch results from a prepared statement into the bound variables',
	'mysqli_stmt_field_count': '(mysqli_stmt $statement): int\nReturns the number of columns in the given statement',
	'mysqli_stmt::free_result': '(): void\nFrees stored result memory for the given statement handle',
	'mysqli_stmt_free_result': '(mysqli_stmt $statement): void\nFrees stored result memory for the given statement handle',
	'mysqli_stmt::get_result': '(): mysqli_result|false\nGets a result set from a prepared statement as a mysqli_result object',
	'mysqli_stmt_get_result': '(mysqli_stmt $statement): mysqli_result|false\nGets a result set from a prepared statement as a mysqli_result object',
	'mysqli_stmt::get_warnings': '(): mysqli_warning|false\nGet result of SHOW WARNINGS',
	'mysqli_stmt_get_warnings': '(mysqli_stmt $statement): mysqli_warning|false\nGet result of SHOW WARNINGS',
	'mysqli_stmt_insert_id': '(mysqli_stmt $statement): int|string\nGet the ID generated from the previous INSERT operation',
	'mysqli_stmt::more_results': '(): bool\nCheck if there are more query results from a multiple query',
	'mysqli_stmt_more_results': '(mysqli_stmt $statement): bool\nCheck if there are more query results from a multiple query',
	'mysqli_stmt::next_result': '(): bool\nReads the next result from a multiple query',
	'mysqli_stmt_next_result': '(mysqli_stmt $statement): bool\nReads the next result from a multiple query',
	'mysqli_stmt::num_rows': '(): int|string\nReturns the number of rows fetched from the server',
	'mysqli_stmt_num_rows': '(mysqli_stmt $statement): int|string\nReturns the number of rows fetched from the server',
	'mysqli_stmt_param_count': '(mysqli_stmt $statement): int\nReturns the number of parameters for the given statement',
	'mysqli_stmt::prepare': '(string $query): bool\nPrepares an SQL statement for execution',
	'mysqli_stmt_prepare': '(mysqli_stmt $statement, string $query): bool\nPrepares an SQL statement for execution',
	'mysqli_stmt::reset': '(): bool\nResets a prepared statement',
	'mysqli_stmt_reset': '(mysqli_stmt $statement): bool\nResets a prepared statement',
	'mysqli_stmt::result_metadata': '(): mysqli_result|false\nReturns result set metadata from a prepared statement',
	'mysqli_stmt_result_metadata': '(mysqli_stmt $statement): mysqli_result|false\nReturns result set metadata from a prepared statement',
	'mysqli_stmt::send_long_data': '(int $param_num, string $data): bool\nSend data in blocks',
	'mysqli_stmt_send_long_data': '(mysqli_stmt $statement, int $param_num, string $data): bool\nSend data in blocks',
	'mysqli_stmt_sqlstate': '(mysqli_stmt $statement): string\nReturns SQLSTATE error from previous statement operation',
	'mysqli_stmt::store_result': '(): bool\nStores a result set in an internal buffer',
	'mysqli_stmt_store_result': '(mysqli_stmt $statement): bool\nStores a result set in an internal buffer',
	'mysqli_warning::next': '(): bool\nFetch next warning',
	'openssl_cipher_iv_length': '(string $cipher_algo): int|false\nGets the cipher iv length',
	'openssl_cipher_key_length': '(string $cipher_algo): int|false\nGets the cipher key length',
	'openssl_cms_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nDecrypt a CMS message',
	'openssl_cms_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, array|null $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt a CMS message',
	'openssl_cms_read': '(string $input_filename, array $certificates): bool\nExport the CMS file to an array of PEM certificates',
	'openssl_cms_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, array|null $headers, int $flags = ?, int $encoding = OPENSSL_ENCODING_SMIME, string|null $untrusted_certificates_filename = null): bool\nSign a file',
	'openssl_cms_verify': '(string $input_filename, int $flags = ?, string|null $certificates = null, array $ca_info = [], string|null $untrusted_certificates_filename = null, string|null $content = null, string|null $pk7 = null, string|null $sigfile = null, int $encoding = OPENSSL_ENCODING_SMIME): bool\nVerify a CMS signature',
	'openssl_csr_export_to_file': '(OpenSSLCertificateSigningRequest|string $csr, string $output_filename, bool $no_text = true): bool\nExports a CSR to a file',
	'openssl_csr_export': '(OpenSSLCertificateSigningRequest|string $csr, string $output, bool $no_text = true): bool\nExports a CSR as a string',
	'openssl_csr_get_public_key': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): OpenSSLAsymmetricKey|false\nReturns the public key of a CSR',
	'openssl_csr_get_subject': '(OpenSSLCertificateSigningRequest|string $csr, bool $short_names = true): array|false\nReturns the subject of a CSR',
	'openssl_csr_new': '(array $distinguished_names, OpenSSLAsymmetricKey|null $private_key, array|null $options = null, array|null $extra_attributes = null): OpenSSLCertificateSigningRequest|bool\nGenerates a CSR',
	'openssl_csr_sign': '(OpenSSLCertificateSigningRequest|string $csr, OpenSSLCertificate|string|null $ca_certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $days, array|null $options = null, int $serial = ?, string|null $serial_hex = null): OpenSSLCertificate|false\nSign a CSR with another certificate (or itself) and generate a certificate',
	'openssl_decrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", string|null $tag = null, string $aad = ""): string|false\nDecrypts data',
	'openssl_dh_compute_key': '(string $public_key, OpenSSLAsymmetricKey $private_key): string|false\nComputes shared secret for public value of remote DH public key and local DH key',
	'openssl_digest': '(string $data, string $digest_algo, bool $binary = false): string|false\nComputes a digest',
	'openssl_encrypt': '(string $data, string $cipher_algo, string $passphrase, int $options = ?, string $iv = "", string $tag = null, string $aad = "", int $tag_length = 16): string|false\nEncrypts data',
	'openssl_error_string': '(): string|false\nReturn openSSL error message',
	'openssl_free_key': '(OpenSSLAsymmetricKey $key): void\nFree key resource',
	'openssl_get_cert_locations': '(): array\nRetrieve the available certificate locations',
	'openssl_get_cipher_methods': '(bool $aliases = false): array\nGets available cipher methods',
	'openssl_get_curve_names': '(): array|false\nGets list of available curve names for ECC',
	'openssl_get_md_methods': '(bool $aliases = false): array\nGets available digest methods',
	'openssl_get_privatekey': 'Alias of openssl_pkey_get_private',
	'openssl_get_publickey': 'Alias of openssl_pkey_get_public',
	'openssl_open': '(string $data, string $output, string $encrypted_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $cipher_algo, string|null $iv = null): bool\nOpen sealed data',
	'openssl_pbkdf2': '(string $password, string $salt, int $key_length, int $iterations, string $digest_algo = "sha1"): string|false\nGenerates a PKCS5 v2 PBKDF2 string',
	'openssl_pkcs12_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File',
	'openssl_pkcs12_export': '(OpenSSLCertificate|string $certificate, string $output, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string $passphrase, array $options = []): bool\nExports a PKCS#12 Compatible Certificate Store File to variable',
	'openssl_pkcs12_read': '(string $pkcs12, array $certificates, string $passphrase): bool\nParse a PKCS#12 Certificate Store into an array',
	'openssl_pkcs7_decrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $private_key = null): bool\nDecrypts an S/MIME encrypted message',
	'openssl_pkcs7_encrypt': '(string $input_filename, string $output_filename, OpenSSLCertificate|array|string $certificate, array|null $headers, int $flags = ?, int $cipher_algo = OPENSSL_CIPHER_AES_128_CBC): bool\nEncrypt an S/MIME message',
	'openssl_pkcs7_read': '(string $data, array $certificates): bool\nExport the PKCS7 file to an array of PEM certificates',
	'openssl_pkcs7_sign': '(string $input_filename, string $output_filename, OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, array|null $headers, int $flags = PKCS7_DETACHED, string|null $untrusted_certificates_filename = null): bool\nSign an S/MIME message',
	'openssl_pkcs7_verify': '(string $input_filename, int $flags, string|null $signers_certificates_filename = null, array $ca_info = [], string|null $untrusted_certificates_filename = null, string|null $content = null, string|null $output_filename = null): bool|int\nVerifies the signature of an S/MIME signed message',
	'openssl_pkey_derive': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $key_length = ?): string|false\nComputes shared secret for public value of remote and local DH or ECDH key',
	'openssl_pkey_export_to_file': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string $output_filename, string|null $passphrase = null, array|null $options = null): bool\nGets an exportable representation of a key into a file',
	'openssl_pkey_export': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key, string $output, string|null $passphrase = null, array|null $options = null): bool\nGets an exportable representation of a key into a string',
	'openssl_pkey_free': '(OpenSSLAsymmetricKey $key): void\nFrees a private key',
	'openssl_pkey_get_details': '(OpenSSLAsymmetricKey $key): array|false\nReturns an array with the key details',
	'openssl_pkey_get_private': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string|null $passphrase = null): OpenSSLAsymmetricKey|false\nGet a private key',
	'openssl_pkey_get_public': '(OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): OpenSSLAsymmetricKey|false\nExtract public key from certificate and prepare it for use',
	'openssl_pkey_new': '(array|null $options = null): OpenSSLAsymmetricKey|false\nGenerates a new private key',
	'openssl_private_decrypt': '(string $data, string $decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nDecrypts data with private key',
	'openssl_private_encrypt': '(string $data, string $encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nEncrypts data with private key',
	'openssl_public_decrypt': '(string $data, string $decrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nDecrypts data with public key',
	'openssl_public_encrypt': '(string $data, string $encrypted_data, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, int $padding = OPENSSL_PKCS1_PADDING): bool\nEncrypts data with public key',
	'openssl_random_pseudo_bytes': '(int $length, bool $strong_result = null): string\nGenerate a pseudo-random string of bytes',
	'openssl_seal': '(string $data, string $sealed_data, array $encrypted_keys, array $public_key, string $cipher_algo, string $iv = null): int|false\nSeal (encrypt) data',
	'openssl_sign': '(string $data, string $signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key, string|int $algorithm = OPENSSL_ALGO_SHA1): bool\nGenerate signature',
	'openssl_spki_export_challenge': '(string $spki): string|false\nExports the challenge associated with a signed public key and challenge',
	'openssl_spki_export': '(string $spki): string|false\nExports a valid PEM formatted public key signed public key and challenge',
	'openssl_spki_new': '(OpenSSLAsymmetricKey $private_key, string $challenge, int $digest_algo = OPENSSL_ALGO_MD5): string|false\nGenerate a new signed public key and challenge',
	'openssl_spki_verify': '(string $spki): bool\nVerifies a signed public key and challenge',
	'openssl_verify': '(string $data, string $signature, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key, string|int $algorithm = OPENSSL_ALGO_SHA1): int|false\nVerify signature',
	'openssl_x509_check_private_key': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $private_key): bool\nChecks if a private key corresponds to a certificate',
	'openssl_x509_checkpurpose': '(OpenSSLCertificate|string $certificate, int $purpose, array $ca_info = [], string|null $untrusted_certificates_file = null): bool|int\nVerifies if a certificate can be used for a particular purpose',
	'openssl_x509_export_to_file': '(OpenSSLCertificate|string $certificate, string $output_filename, bool $no_text = true): bool\nExports a certificate to file',
	'openssl_x509_export': '(OpenSSLCertificate|string $certificate, string $output, bool $no_text = true): bool\nExports a certificate as a string',
	'openssl_x509_fingerprint': '(OpenSSLCertificate|string $certificate, string $digest_algo = "sha1", bool $binary = false): string|false\nCalculates the fingerprint, or digest, of a given X.509 certificate',
	'openssl_x509_free': '(OpenSSLCertificate $certificate): void\nFree certificate resource',
	'openssl_x509_parse': '(OpenSSLCertificate|string $certificate, bool $short_names = true): array|false\nParse an X509 certificate and return the information as an array',
	'openssl_x509_read': '(OpenSSLCertificate|string $certificate): OpenSSLCertificate|false\nParse an X.509 certificate and return an object for it',
	'openssl_x509_verify': '(OpenSSLCertificate|string $certificate, OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $public_key): int\nVerifies digital signature of x509 certificate against a public key',
	'Pdo\\Firebird::getApiVersion': '(): int\nGet the API version',
	'Pdo\\Mysql::getWarningCount': '(): int\nReturns the number of warnings from the last executed query',
	'Pdo\\Pgsql::copyFromArray': '(string $tableName, array $rows, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from a PHP array into a table',
	'Pdo\\Pgsql::copyFromFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from file into table',
	'Pdo\\Pgsql::copyToArray': '(string $tableName, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): array|false\nCopy data from database table into PHP array',
	'Pdo\\Pgsql::copyToFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nCopy data from table into file',
	'Pdo\\Pgsql::escapeIdentifier': '(string $input): string\nEscapes a string for use as an SQL identifier',
	'Pdo\\Pgsql::getNotify': '(int $fetchMode = PDO::FETCH_DEFAULT, int $timeoutMilliseconds = ?): array|false\nGet asynchronous notification',
	'Pdo\\Pgsql::getPid': '(): int\nGet the PID of the backend process handling this connection',
	'Pdo\\Pgsql::lobCreate': '(): string|false\nCreates a new large object',
	'Pdo\\Pgsql::lobOpen': '(string $oid, string $mode = "rb"): resource|false\nOpens an existing large object stream',
	'Pdo\\Pgsql::lobUnlink': '(string $oid): bool\nDeletes the large object',
	'Pdo\\Pgsql::setNoticeCallback': '(callable|null $callback): void\nSet a callback to handle notice and warning messages generated by the backend',
	'PDO::pgsqlCopyFromArray': '(string $tableName, array $rows, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyFromArray',
	'PDO::pgsqlCopyFromFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyFromFile',
	'PDO::pgsqlCopyToArray': '(string $tableName, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): array|false\nAlias Pdo\\Pgsql::copyToArray',
	'PDO::pgsqlCopyToFile': '(string $tableName, string $filename, string $separator = "\\t", string $nullAs = "\\\\\\\\N", string|null $fields = null): bool\nAlias Pdo\\Pgsql::copyToFile',
	'PDO::pgsqlGetNotify': '(int $fetchMode = PDO::FETCH_DEFAULT, int $timeoutMilliseconds = ?): array|false\nAlias Pdo\\Pgsql::getNotify',
	'PDO::pgsqlGetPid': '(): int\nAlias Pdo\\Pgsql::getPid',
	'PDO::pgsqlLOBCreate': '(): string\nAlias Pdo\\Pgsql::lobCreate',
	'PDO::pgsqlLOBOpen': '(string $oid, string $mode = "rb"): resource|false\nAlias Pdo\\Pgsql::lobOpen',
	'PDO::pgsqlLOBUnlink': '(string $oid): bool\nAlias Pdo\\Pgsql::lobUnlink',
	'Pdo\\Sqlite::createAggregate': '(string $name, callable $step, callable $finalize, int $numArgs = -1): bool\nRegisters an aggregating user-defined function for use in SQL statements',
	'Pdo\\Sqlite::createCollation': '(string $name, callable $callback): bool\nRegisters a user-defined function for use as a collating function in SQL statements',
	'Pdo\\Sqlite::createFunction': '(string $function_name, callable $callback, int $num_args = -1, int $flags = ?): bool\nRegisters a user-defined function for use in SQL statements',
	'Pdo\\Sqlite::loadExtension': '(string $name): void\nDescription',
	'Pdo\\Sqlite::openBlob': '(string $table, string $column, int $rowid, string|null $dbname = "main", int $flags = Pdo\\Sqlite::OPEN_READONLY): resource|false\nDescription',
	'PDO::sqliteCreateAggregate': '(string $name, callable $step, callable $finalize, int $numArgs = -1): bool\nAlias Pdo\\Sqlite::createAggregate',
	'PDO::sqliteCreateCollation': '(string $name, callable $callback): bool\nAlias Pdo\\Sqlite::createCollation',
	'PDO::sqliteCreateFunction': '(string $function_name, callable $callback, int $num_args = -1, int $flags = ?): bool\nAlias Pdo\\Sqlite::createFunction',
	'pg_affected_rows': '(PgSql\\Result $result): int\nReturns number of affected records (tuples)',
	'pg_cancel_query': '(PgSql\\Connection $connection): bool\nCancel an asynchronous query',
	'pg_client_encoding': '(PgSql\\Connection|null $connection = null): string\nGets the client encoding',
	'pg_close': '(PgSql\\Connection|null $connection = null): true\nCloses a PostgreSQL connection',
	'pg_connect_poll': '(PgSql\\Connection $connection): int\nPoll the status of an in-progress asynchronous PostgreSQL connection attempt',
	'pg_connect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a PostgreSQL connection',
	'pg_connection_busy': '(PgSql\\Connection $connection): bool\nGet connection is busy or not',
	'pg_connection_reset': '(PgSql\\Connection $connection): bool\nReset connection (reconnect)',
	'pg_connection_status': '(PgSql\\Connection $connection): int\nGet connection status',
	'pg_consume_input': '(PgSql\\Connection $connection): bool\nReads input on the connection',
	'pg_convert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = ?): array|false\nConvert associative array values into forms suitable for SQL statements',
	'pg_copy_from': '(PgSql\\Connection $connection, string $table_name, array $rows, string $separator = "\\t", string $null_as = "\\\\\\\\N"): bool\nInsert records into a table from an array',
	'pg_copy_to': '(PgSql\\Connection $connection, string $table_name, string $separator = "\\t", string $null_as = "\\\\\\\\N"): array|false\nCopy a table to an array',
	'pg_dbname': '(PgSql\\Connection|null $connection = null): string\nGet the database name',
	'pg_delete': '(PgSql\\Connection $connection, string $table_name, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nDeletes records',
	'pg_end_copy': '(PgSql\\Connection|null $connection = null): bool\nSync with PostgreSQL backend',
	'pg_escape_bytea': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a string for insertion into a bytea field',
	'pg_escape_identifier': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a identifier for insertion into a text field',
	'pg_escape_literal': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a literal for insertion into a text field',
	'pg_escape_string': '(PgSql\\Connection $connection = ?, string $data): string\nEscape a string for query',
	'pg_execute': '(PgSql\\Connection $connection = ?, string $stmtname, array $params): PgSql\\Result|false\nSends a request to execute a prepared statement with given parameters, and waits for the result',
	'pg_fetch_all_columns': '(PgSql\\Result $result, int $field = ?): array\nFetches all rows in a particular result column as an array',
	'pg_fetch_all': '(PgSql\\Result $result, int $mode = PGSQL_ASSOC): array\nFetches all rows from a result as an array',
	'pg_fetch_array': '(PgSql\\Result $result, int|null $row = null, int $mode = PGSQL_BOTH): array|false\nFetch a row as an array',
	'pg_fetch_assoc': '(PgSql\\Result $result, int|null $row = null): array|false\nFetch a row as an associative array',
	'pg_fetch_object': '(PgSql\\Result $result, int|null $row = null, string $class = "stdClass", array $constructor_args = []): object|false\nFetch a row as an object',
	'pg_fetch_result': '(PgSql\\Result $result, string|false|null $row, mixed $field): string|false|null\nReturns values from a result instance',
	'pg_fetch_result': '(PgSql\\Result $result, mixed $field): string|false|null\nReturns values from a result instance',
	'pg_fetch_row': '(PgSql\\Result $result, int|null $row = null, int $mode = PGSQL_NUM): array|false\nGet a row as an enumerated array',
	'pg_field_is_null': '(PgSql\\Result $result, string|false|null $row, mixed $field): int\nTest if a field is SQL NULL',
	'pg_field_is_null': '(PgSql\\Result $result, mixed $field): int\nTest if a field is SQL NULL',
	'pg_field_name': '(PgSql\\Result $result, int $field): string\nReturns the name of a field',
	'pg_field_num': '(PgSql\\Result $result, string $field): int\nReturns the field number of the named field',
	'pg_field_prtlen': '(PgSql\\Result $result, string|false|null $row, mixed $field_name_or_number): int\nReturns the printed length',
	'pg_field_prtlen': '(PgSql\\Result $result, mixed $field_name_or_number): int\nReturns the printed length',
	'pg_field_size': '(PgSql\\Result $result, int $field): int\nReturns the internal storage size of the named field',
	'pg_field_table': '(PgSql\\Result $result, int $field, bool $oid_only = false): string|int|false\nReturns the name or oid of the tables field',
	'pg_field_type_oid': '(PgSql\\Result $result, int $field): string|int\nReturns the type ID (OID) for the corresponding field number',
	'pg_field_type': '(PgSql\\Result $result, int $field): string\nReturns the type name for the corresponding field number',
	'pg_flush': '(PgSql\\Connection $connection): int|bool\nFlush outbound query data on the connection',
	'pg_free_result': '(PgSql\\Result $result): bool\nFree result memory',
	'pg_get_notify': '(PgSql\\Connection $connection, int $mode = PGSQL_ASSOC): array|false\nGets SQL NOTIFY message',
	'pg_get_pid': '(PgSql\\Connection $connection): int\nGets the backend\'s process ID',
	'pg_get_result': '(PgSql\\Connection $connection): PgSql\\Result|false\nGet asynchronous query result',
	'pg_host': '(PgSql\\Connection|null $connection = null): string\nReturns the host name associated with the connection',
	'pg_insert': '(PgSql\\Connection $connection, string $table_name, array $values, int $flags = PGSQL_DML_EXEC): PgSql\\Result|string|bool\nInsert array into table',
	'pg_last_error': '(PgSql\\Connection|null $connection = null): string\nGet the last error message string of a connection',
	'pg_last_notice': '(PgSql\\Connection $connection, int $mode = PGSQL_NOTICE_LAST): array|string|bool\nReturns the last notice message from PostgreSQL server',
	'pg_last_oid': '(PgSql\\Result $result): string|int|false\nReturns the last row\'s OID',
	'pg_lo_close': '(PgSql\\Lob $lob): bool\nClose a large object',
	'pg_lo_create': '(PgSql\\Connection $connection = ?, mixed $object_id = ?): int\nCreate a large object',
	'pg_lo_create': '(mixed $object_id): int\nCreate a large object',
	'pg_lo_export': '(PgSql\\Connection $connection = ?, int $oid, string $pathname): bool\nExport a large object to file',
	'pg_lo_import': '(PgSql\\Connection $connection = ?, string $pathname, mixed $object_id = ?): int\nImport a large object from file',
	'pg_lo_open': '(PgSql\\Connection $connection, int $oid, string $mode): PgSql\\Lob|false\nOpen a large object',
	'pg_lo_read_all': '(PgSql\\Lob $lob): int\nReads an entire large object and send straight to browser',
	'pg_lo_read': '(PgSql\\Lob $lob, int $length = 8192): string|false\nRead a large object',
	'pg_lo_seek': '(PgSql\\Lob $lob, int $offset, int $whence = SEEK_CUR): bool\nSeeks position within a large object',
	'pg_lo_tell': '(PgSql\\Lob $lob): int\nReturns current seek position a of large object',
	'pg_lo_truncate': '(PgSql\\Lob $lob, int $size): bool\nTruncates a large object',
	'pg_lo_unlink': '(PgSql\\Connection $connection, int $oid): bool\nDelete a large object',
	'pg_lo_write': '(PgSql\\Lob $lob, string $data, int|null $length = null): int|false\nWrite to a large object',
	'pg_meta_data': '(PgSql\\Connection $connection, string $table_name, bool $extended = false): array|false\nGet meta data for table',
	'pg_num_fields': '(PgSql\\Result $result): int\nReturns the number of fields in a result',
	'pg_num_rows': '(PgSql\\Result $result): int\nReturns the number of rows in a result',
	'pg_options': '(PgSql\\Connection|null $connection = null): string\nGet the options associated with the connection',
	'pg_parameter_status': '(PgSql\\Connection $connection = ?, string $param_name): string\nLooks up a current parameter setting of the server',
	'pg_pconnect': '(string $connection_string, int $flags = ?): PgSql\\Connection|false\nOpen a persistent PostgreSQL connection',
	'pg_ping': '(PgSql\\Connection|null $connection = null): bool\nPing database connection',
	'pg_port': '(PgSql\\Connection|null $connection = null): string\nReturn the port number associated with the connection',
	'pg_prepare': '(PgSql\\Connection $connection = ?, string $stmtname, string $query): PgSql\\Result|false\nSubmits a request to the server to create a prepared statement with the given parameters, and waits for completion',
	'pg_put_line': '(PgSql\\Connection $connection = ?, string $data): bool\nSend a NULL-terminated string to PostgreSQL backend',
	'pg_query_params': '(PgSql\\Connection $connection = ?, string $query, array $params): PgSql\\Result|false\nSubmits a command to the server and waits for the result, with the ability to pass parameters separately from the SQL command text',
	'pg_query': '(PgSql\\Connection $connection = ?, string $query): PgSql\\Result|false\nExecute a query',
	'pg_result_error_field': '(PgSql\\Result $result, int $field_code): string|false|null\nReturns an individual field of an error report',
	'pg_result_error': '(PgSql\\Result $result): string|false\nGet error message associated with result',
	'pg_result_memory_size': '(PgSql\\Result $result): int\nReturns the amount of memory allocated for a query result',
	'pg_result_seek': '(PgSql\\Result $result, int $row): bool\nSet internal row offset in result instance',
	'pg_result_status': '(PgSql\\Result $result, int $mode = PGSQL_STATUS_LONG): string|int\nGet status of query result',
	'pg_select': '(PgSql\\Connection $connection, string $table_name, array $conditions = [], int $flags = PGSQL_DML_EXEC, int $mode = PGSQL_ASSOC): array|string|false\nSelect records',
	'pg_send_execute': '(PgSql\\Connection $connection, string $statement_name, array $params): int|bool\nSends a request to execute a prepared statement with given parameters, without waiting for the result(s)',
	'pg_send_prepare': '(PgSql\\Connection $connection, string $statement_name, string $query): int|bool\nSends a request to create a prepared statement with the given parameters, without waiting for completion',
	'pg_send_query_params': '(PgSql\\Connection $connection, string $query, array $params): int|bool\nSubmits a command and separate parameters to the server without waiting for the result(s)',
	'pg_send_query': '(PgSql\\Connection $connection, string $query): int|bool\nSends asynchronous query',
	'pg_set_chunked_rows_size': '(PgSql\\Connection $connection, int $size): bool\nSet the query results to be retrieved in chunk mode',
	'pg_set_client_encoding': '(PgSql\\Connection $connection = ?, string $encoding): int\nSet the client encoding',
	'pg_set_error_context_visibility': '(PgSql\\Connection $connection, int $visibility): int\nDetermines the visibility of the context\'s error messages returned by pg_last_error and pg_result_error',
	'pg_set_error_verbosity': '(PgSql\\Connection $connection = ?, int $verbosity): int\nDetermines the verbosity of messages returned by pg_last_error and pg_result_error',
	'pg_socket': '(PgSql\\Connection $connection): resource|false\nGet a read only handle to the socket underlying a PostgreSQL connection',
	'pg_trace': '(string $filename, string $mode = "w", PgSql\\Connection|null $connection = null, int $trace_mode = ?): bool\nEnable tracing a PostgreSQL connection',
	'pg_transaction_status': '(PgSql\\Connection $connection): int\nReturns the current in-transaction status of the server',
	'pg_tty': '(PgSql\\Connection|null $connection = null): string\nReturn the TTY name associated with the connection',
	'pg_unescape_bytea': '(string $string): string\nUnescape binary for bytea type',
	'pg_untrace': '(PgSql\\Connection|null $connection = null): true\nDisable tracing of a PostgreSQL connection',
	'pg_update': '(PgSql\\Connection $connection, string $table_name, array $values, array $conditions, int $flags = PGSQL_DML_EXEC): string|bool\nUpdate table',
	'pg_version': '(PgSql\\Connection|null $connection = null): array\nReturns an array with client, protocol and server version (when available)',
	'readline_add_history': '(string $prompt): true\nAdds a line to the history',
	'readline_callback_handler_install': '(string $prompt, callable $callback): true\nInitializes the readline callback interface and terminal, prints the prompt and returns immediately',
	'readline_callback_handler_remove': '(): bool\nRemoves a previously installed callback handler and restores terminal settings',
	'readline_callback_read_char': '(): void\nReads a character and informs the readline callback interface when a line is received',
	'readline_clear_history': '(): true\nClears the history',
	'readline_completion_function': '(callable $callback): bool\nRegisters a completion function',
	'readline_info': '(string|null $var_name = null, int|string|bool|null $value = null): mixed\nGets/sets various internal readline variables',
	'readline_list_history': '(): array\nLists the history',
	'readline_on_new_line': '(): void\nInform readline that the cursor has moved to a new line',
	'readline_read_history': '(string|null $filename = null): bool\nReads the history',
	'readline_redisplay': '(): void\nRedraws the display',
	'readline_write_history': '(string|null $filename = null): bool\nWrites the history',
	'readline': '(string|null $prompt = null): string|false\nReads a line',
	'simplexml_import_dom': '(object $node, string|null $class_name = SimpleXMLElement::class): SimpleXMLElement|null\nGet a SimpleXMLElement object from an XML or HTML node',
	'simplexml_load_file': '(string $filename, string|null $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets an XML file into an object',
	'simplexml_load_string': '(string $data, string|null $class_name = SimpleXMLElement::class, int $options = ?, string $namespace_or_prefix = "", bool $is_prefix = false): SimpleXMLElement|false\nInterprets a string of XML into an object',
	'SimpleXMLElement::addAttribute': '(string $qualifiedName, string $value, string|null $namespace = null): void\nAdds an attribute to the SimpleXML element',
	'SimpleXMLElement::addChild': '(string $qualifiedName, string|null $value = null, string|null $namespace = null): SimpleXMLElement|null\nAdds a child element to the XML node',
	'SimpleXMLElement::asXML': '(string|null $filename = null): string|bool\nReturn a well-formed XML string based on SimpleXML element',
	'SimpleXMLElement::attributes': '(string|null $namespaceOrPrefix = null, bool $isPrefix = false): SimpleXMLElement|null\nIdentifies an element\'s attributes',
	'SimpleXMLElement::children': '(string|null $namespaceOrPrefix = null, bool $isPrefix = false): SimpleXMLElement|null\nFinds children of given node',
	'SimpleXMLElement::count': '(): int\nCounts the children of an element',
	'SimpleXMLElement::current': '(): SimpleXMLElement\nReturns the current element',
	'SimpleXMLElement::getDocNamespaces': '(bool $recursive = false, bool $fromRoot = true): array|false\nReturns namespaces declared in document',
	'SimpleXMLElement::getName': '(): string\nGets the name of the XML element',
	'SimpleXMLElement::getNamespaces': '(bool $recursive = false): array\nReturns namespaces used in document',
	'SimpleXMLElement::getChildren': '(): SimpleXMLElement|null\nReturns the sub-elements of the current element',
	'SimpleXMLElement::hasChildren': '(): bool\nChecks whether the current element has sub elements',
	'SimpleXMLElement::key': '(): string\nReturn current key',
	'SimpleXMLElement::next': '(): void\nMove to next element',
	'SimpleXMLElement::registerXPathNamespace': '(string $prefix, string $namespace): bool\nCreates a prefix/ns context for the next XPath query',
	'SimpleXMLElement::rewind': '(): void\nRewind to the first element',
	'SimpleXMLElement::saveXML': 'Alias of SimpleXMLElement::asXML',
	'SimpleXMLElement::__toString': '(): string\nReturns the string content',
	'SimpleXMLElement::valid': '(): bool\nCheck whether the current element is valid',
	'SimpleXMLElement::xpath': '(string $expression): array|null|false\nRuns XPath query on XML data',
	'snmp_get_quick_print': '(): bool\nFetches the current value of the NET-SNMP library\'s quick_print setting',
	'snmp_get_valueretrieval': '(): int\nReturn the method how the SNMP values will be returned',
	'snmp_read_mib': '(string $filename): bool\nReads and parses a MIB file into the active MIB tree',
	'snmp_set_enum_print': '(bool $enable): true\nReturn all values that are enums with their enum value instead of the raw integer',
	'snmp_set_oid_numeric_print': 'Alias of snmp_set_oid_output_format',
	'snmp_set_oid_output_format': '(int $format): true\nSet the OID output format',
	'snmp_set_quick_print': '(bool $enable): true\nSet the value of $enable within the NET-SNMP library',
	'snmp_set_valueretrieval': '(int $method): true\nSpecify the method how the SNMP values will be returned',
	'snmp2_get': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
	'snmp2_getnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
	'snmp2_real_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
	'snmp2_set': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
	'snmp2_walk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
	'snmp3_get': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
	'snmp3_getnext': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
	'snmp3_real_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
	'snmp3_set': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
	'snmp3_walk': '(string $hostname, string $security_name, string $security_level, string $auth_protocol, string $auth_passphrase, string $privacy_protocol, string $privacy_passphrase, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
	'snmpget': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch an SNMP object',
	'snmpgetnext': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): mixed\nFetch the SNMP object which follows the given object id',
	'snmprealwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nReturn all objects including their respective object ID within the specified one',
	'snmpset': '(string $hostname, string $community, array|string $object_id, array|string $type, array|string $value, int $timeout = -1, int $retries = -1): bool\nSet the value of an SNMP object',
	'snmpwalk': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nFetch all the SNMP objects from an agent',
	'snmpwalkoid': '(string $hostname, string $community, array|string $object_id, int $timeout = -1, int $retries = -1): array|false\nQuery for a tree of information about a network entity',
	'SNMP::close': '(): bool\nClose SNMP session',
	'SNMP::get': '(array|string $objectId, bool $preserveKeys = false): mixed\nFetch an SNMP object',
	'SNMP::getErrno': '(): int\nGet last error code',
	'SNMP::getError': '(): string\nGet last error message',
	'SNMP::getnext': '(array|string $objectId): mixed\nFetch an SNMP object which follows the given object id',
	'SNMP::set': '(array|string $objectId, array|string $type, array|string $value): bool\nSet the value of an SNMP object',
	'SNMP::setSecurity': '(string $securityLevel, string $authProtocol = "", string $authPassphrase = "", string $privacyProtocol = "", string $privacyPassphrase = "", string $contextName = "", string $contextEngineId = ""): bool\nConfigures security-related SNMPv3 session parameters',
	'SNMP::walk': '(array|string $objectId, bool $suffixAsKey = false, int $maxRepetitions = -1, int $nonRepeaters = -1): array|false\nFetch SNMP object subtree',
	'is_soap_fault': '(mixed $object): bool\nChecks if a SOAP call has failed',
	'use_soap_error_handler': '(bool $enable = true): bool\nSet whether to use the SOAP error handler',
	'SoapClient::__call': '(string $name, array $args): mixed\nCalls a SOAP function (deprecated)',
	'SoapClient::__doRequest': '(string $request, string $location, string $action, int $version, bool $oneWay = false): string|null\nPerforms a SOAP request',
	'SoapClient::__getCookies': '(): array\nGet list of cookies',
	'SoapClient::__getFunctions': '(): array|null\nReturns list of available SOAP functions',
	'SoapClient::__getLastRequest': '(): string|null\nReturns last SOAP request',
	'SoapClient::__getLastRequestHeaders': '(): string|null\nReturns the SOAP headers from the last request',
	'SoapClient::__getLastResponse': '(): string|null\nReturns last SOAP response',
	'SoapClient::__getLastResponseHeaders': '(): string|null\nReturns the SOAP headers from the last response',
	'SoapClient::__getTypes': '(): array|null\nReturns a list of SOAP types',
	'SoapClient::__setCookie': '(string $name, string|null $value = null): void\nDefines a cookie for SOAP requests',
	'SoapClient::__setLocation': '(string|null $location = null): string|null\nSets the location of the Web service to use',
	'SoapClient::__setSoapHeaders': '(SoapHeader|array|null $headers = null): bool\nSets SOAP headers for subsequent calls',
	'SoapClient::__soapCall': '(string $name, array $args, array|null $options = null, SoapHeader|array|null $inputHeaders = null, array $outputHeaders = null): mixed\nCalls a SOAP function',
	'SoapFault::__toString': '(): string\nObtain a string representation of a SoapFault',
	'SoapServer::addFunction': '(array|string|int $functions): void\nAdds one or more functions to handle SOAP requests',
	'SoapServer::addSoapHeader': '(SoapHeader $header): void\nAdd a SOAP header to the response',
	'SoapServer::fault': '(string $code, string $string, string $actor = "", mixed $details = null, string $name = ""): void\nIssue SoapServer fault indicating an error',
	'SoapServer::getFunctions': '(): array\nReturns list of defined functions',
	'SoapServer::__getLastResponse': '(): string|null\nReturns last SOAP response',
	'SoapServer::handle': '(string|null $request = null): void\nHandles a SOAP request',
	'SoapServer::setClass': '(string $class, mixed ...$args): void\nSets the class which handles SOAP requests',
	'SoapServer::setObject': '(object $object): void\nSets the object which will be used to handle SOAP requests',
	'SoapServer::setPersistence': '(int $mode): void\nSets SoapServer persistence mode',
	'sodium_add': '(string $string1, string $string2): void\nAdd large numbers',
	'sodium_base642bin': '(string $string, int $id, string $ignore = ""): string\nDecodes a base64-encoded string into raw binary.',
	'sodium_bin2base64': '(string $string, int $id): string\nEncodes a raw binary string with base64.',
	'sodium_bin2hex': '(string $string): string\nEncode to hexadecimal',
	'sodium_compare': '(string $string1, string $string2): int\nCompare large numbers',
	'sodium_crypto_aead_aegis128l_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-128L',
	'sodium_crypto_aead_aegis128l_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-128L',
	'sodium_crypto_aead_aegis128l_keygen': '(): string\nGenerate a random AEGIS-128L key',
	'sodium_crypto_aead_aegis256_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AEGIS-256',
	'sodium_crypto_aead_aegis256_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate a message with AEGIS-256',
	'sodium_crypto_aead_aegis256_keygen': '(): string\nGenerate a random AEGIS-256 key',
	'sodium_crypto_aead_aes256gcm_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt a message with AES-256-GCM',
	'sodium_crypto_aead_aes256gcm_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with AES-256-GCM',
	'sodium_crypto_aead_aes256gcm_is_available': '(): bool\nCheck if hardware supports AES256-GCM',
	'sodium_crypto_aead_aes256gcm_keygen': '(): string\nGenerate a random AES-256-GCM key',
	'sodium_crypto_aead_chacha20poly1305_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify then decrypt with ChaCha20-Poly1305',
	'sodium_crypto_aead_chacha20poly1305_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt then authenticate with ChaCha20-Poly1305',
	'sodium_crypto_aead_chacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\nVerify that the ciphertext includes a valid tag',
	'sodium_crypto_aead_chacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\nEncrypt a message',
	'sodium_crypto_aead_chacha20poly1305_ietf_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 (IETF) key.',
	'sodium_crypto_aead_chacha20poly1305_keygen': '(): string\nGenerate a random ChaCha20-Poly1305 key.',
	'sodium_crypto_aead_xchacha20poly1305_ietf_decrypt': '(string $ciphertext, string $additional_data, string $nonce, string $key): string|false\n(Preferred) Verify then decrypt with XChaCha20-Poly1305',
	'sodium_crypto_aead_xchacha20poly1305_ietf_encrypt': '(string $message, string $additional_data, string $nonce, string $key): string\n(Preferred) Encrypt then authenticate with XChaCha20-Poly1305',
	'sodium_crypto_aead_xchacha20poly1305_ietf_keygen': '(): string\nGenerate a random XChaCha20-Poly1305 key.',
	'sodium_crypto_auth_keygen': '(): string\nGenerate a random key for sodium_crypto_auth',
	'sodium_crypto_auth_verify': '(string $mac, string $message, string $key): bool\nVerifies that the tag is valid for the message',
	'sodium_crypto_auth': '(string $message, string $key): string\nCompute a tag for the message',
	'sodium_crypto_box_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nCreate a unified keypair string from a secret key and public key',
	'sodium_crypto_box_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
	'sodium_crypto_box_open': '(string $ciphertext, string $nonce, string $key_pair): string|false\nAuthenticated public-key decryption',
	'sodium_crypto_box_publickey_from_secretkey': '(string $secret_key): string\nCalculate the public key from a secret key',
	'sodium_crypto_box_publickey': '(string $key_pair): string\nExtract the public key from a crypto_box keypair',
	'sodium_crypto_box_seal_open': '(string $ciphertext, string $key_pair): string|false\nAnonymous public-key decryption',
	'sodium_crypto_box_seal': '(string $message, string $public_key): string\nAnonymous public-key encryption',
	'sodium_crypto_box_secretkey': '(string $key_pair): string\nExtracts the secret key from a crypto_box keypair',
	'sodium_crypto_box_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
	'sodium_crypto_box': '(string $message, string $nonce, string $key_pair): string\nAuthenticated public-key encryption',
	'sodium_crypto_core_ristretto255_add': '(string $p, string $q): string\nAdds an element',
	'sodium_crypto_core_ristretto255_from_hash': '(string $s): string\nMaps a vector',
	'sodium_crypto_core_ristretto255_is_valid_point': '(string $s): bool\nDetermines if a point on the ristretto255 curve',
	'sodium_crypto_core_ristretto255_random': '(): string\nGenerates a random key',
	'sodium_crypto_core_ristretto255_scalar_add': '(string $x, string $y): string\nAdds a scalar value',
	'sodium_crypto_core_ristretto255_scalar_complement': '(string $s): string\nThe sodium_crypto_core_ristretto255_scalar_complement purpose',
	'sodium_crypto_core_ristretto255_scalar_invert': '(string $s): string\nInverts a scalar value',
	'sodium_crypto_core_ristretto255_scalar_mul': '(string $x, string $y): string\nMultiplies a scalar value',
	'sodium_crypto_core_ristretto255_scalar_negate': '(string $s): string\nNegates a scalar value',
	'sodium_crypto_core_ristretto255_scalar_random': '(): string\nGenerates a random key',
	'sodium_crypto_core_ristretto255_scalar_reduce': '(string $s): string\nReduces a scalar value',
	'sodium_crypto_core_ristretto255_scalar_sub': '(string $x, string $y): string\nSubtracts a scalar value',
	'sodium_crypto_core_ristretto255_sub': '(string $p, string $q): string\nSubtracts an element',
	'sodium_crypto_generichash_final': '(string $state, int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nComplete the hash',
	'sodium_crypto_generichash_init': '(string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nInitialize a hash for streaming',
	'sodium_crypto_generichash_keygen': '(): string\nGenerate a random generichash key',
	'sodium_crypto_generichash_update': '(string $state, string $message): true\nAdd message to a hash',
	'sodium_crypto_generichash': '(string $message, string $key = "", int $length = SODIUM_CRYPTO_GENERICHASH_BYTES): string\nGet a hash of the message',
	'sodium_crypto_kdf_derive_from_key': '(int $subkey_length, int $subkey_id, string $context, string $key): string\nDerive a subkey',
	'sodium_crypto_kdf_keygen': '(): string\nGenerate a random root key for the KDF interface',
	'sodium_crypto_kx_client_session_keys': '(string $client_key_pair, string $server_key): array\nCalculate the client-side session keys.',
	'sodium_crypto_kx_keypair': '(): string\nCreates a new sodium keypair',
	'sodium_crypto_kx_publickey': '(string $key_pair): string\nExtract the public key from a crypto_kx keypair',
	'sodium_crypto_kx_secretkey': '(string $key_pair): string\nExtract the secret key from a crypto_kx keypair.',
	'sodium_crypto_kx_seed_keypair': '(string $seed): string\nDescription',
	'sodium_crypto_kx_server_session_keys': '(string $server_key_pair, string $client_key): array\nCalculate the server-side session keys.',
	'sodium_crypto_pwhash_scryptsalsa208sha256_str_verify': '(string $hash, string $password): bool\nVerify that the password is a valid password verification string',
	'sodium_crypto_pwhash_scryptsalsa208sha256_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII encoded hash',
	'sodium_crypto_pwhash_scryptsalsa208sha256': '(int $length, string $password, string $salt, int $opslimit, int $memlimit): string\nDerives a key from a password, using scrypt',
	'sodium_crypto_pwhash_str_needs_rehash': '(string $password, int $opslimit, int $memlimit): bool\nDetermine whether or not to rehash a password',
	'sodium_crypto_pwhash_str_verify': '(string $hash, string $password): bool\nVerifies that a password matches a hash',
	'sodium_crypto_pwhash_str': '(string $password, int $opslimit, int $memlimit): string\nGet an ASCII-encoded hash',
	'sodium_crypto_pwhash': '(int $length, string $password, string $salt, int $opslimit, int $memlimit, int $algo = SODIUM_CRYPTO_PWHASH_ALG_DEFAULT): string\nDerive a key from a password, using Argon2',
	'sodium_crypto_scalarmult_base': 'Alias of sodium_crypto_box_publickey_from_secretkey',
	'sodium_crypto_scalarmult_ristretto255_base': '(string $n): string\nCalculates the public key from a secret key',
	'sodium_crypto_scalarmult_ristretto255': '(string $n, string $p): string\nComputes a shared secret',
	'sodium_crypto_scalarmult': '(string $n, string $p): string\nCompute a shared secret given a user\'s secret key and another user\'s public key',
	'sodium_crypto_secretbox_keygen': '(): string\nGenerate random key for sodium_crypto_secretbox',
	'sodium_crypto_secretbox_open': '(string $ciphertext, string $nonce, string $key): string|false\nAuthenticated shared-key decryption',
	'sodium_crypto_secretbox': '(string $message, string $nonce, string $key): string\nAuthenticated shared-key encryption',
	'sodium_crypto_secretstream_xchacha20poly1305_init_pull': '(string $header, string $key): string\nInitialize a secretstream context for decryption',
	'sodium_crypto_secretstream_xchacha20poly1305_init_push': '(string $key): array\nInitialize a secretstream context for encryption',
	'sodium_crypto_secretstream_xchacha20poly1305_keygen': '(): string\nGenerate a random secretstream key.',
	'sodium_crypto_secretstream_xchacha20poly1305_pull': '(string $state, string $ciphertext, string $additional_data = ""): array|false\nDecrypt a chunk of data from an encrypted stream',
	'sodium_crypto_secretstream_xchacha20poly1305_push': '(string $state, string $message, string $additional_data = "", int $tag = SODIUM_CRYPTO_SECRETSTREAM_XCHACHA20POLY1305_TAG_MESSAGE): string\nEncrypt a chunk of data so that it can safely be decrypted in a streaming API',
	'sodium_crypto_secretstream_xchacha20poly1305_rekey': '(string $state): void\nExplicitly rotate the key in the secretstream state',
	'sodium_crypto_shorthash_keygen': '(): string\nGet random bytes for key',
	'sodium_crypto_shorthash': '(string $message, string $key): string\nCompute a short hash of a message and key',
	'sodium_crypto_sign_detached': '(string $message, string $secret_key): string\nSign the message',
	'sodium_crypto_sign_ed25519_pk_to_curve25519': '(string $public_key): string\nConvert an Ed25519 public key to a Curve25519 public key',
	'sodium_crypto_sign_ed25519_sk_to_curve25519': '(string $secret_key): string\nConvert an Ed25519 secret key to a Curve25519 secret key',
	'sodium_crypto_sign_keypair_from_secretkey_and_publickey': '(string $secret_key, string $public_key): string\nJoin a secret key and public key together',
	'sodium_crypto_sign_keypair': '(): string\nRandomly generate a secret key and a corresponding public key',
	'sodium_crypto_sign_open': '(string $signed_message, string $public_key): string|false\nCheck that the signed message has a valid signature',
	'sodium_crypto_sign_publickey_from_secretkey': '(string $secret_key): string\nExtract the Ed25519 public key from the secret key',
	'sodium_crypto_sign_publickey': '(string $key_pair): string\nExtract the Ed25519 public key from a keypair',
	'sodium_crypto_sign_secretkey': '(string $key_pair): string\nExtract the Ed25519 secret key from a keypair',
	'sodium_crypto_sign_seed_keypair': '(string $seed): string\nDeterministically derive the key pair from a single key',
	'sodium_crypto_sign_verify_detached': '(string $signature, string $message, string $public_key): bool\nVerify signature for the message',
	'sodium_crypto_sign': '(string $message, string $secret_key): string\nSign a message',
	'sodium_crypto_stream_keygen': '(): string\nGenerate a random sodium_crypto_stream key.',
	'sodium_crypto_stream_xchacha20_keygen': '(): string\nReturns a secure random key',
	'sodium_crypto_stream_xchacha20_xor_ic': '(string $message, string $nonce, int $counter, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
	'sodium_crypto_stream_xchacha20_xor': '(string $message, string $nonce, string $key): string\nEncrypts a message using a nonce and a secret key (no authentication)',
	'sodium_crypto_stream_xchacha20': '(int $length, string $nonce, string $key): string\nExpands the key and nonce into a keystream of pseudorandom bytes',
	'sodium_crypto_stream_xor': '(string $message, string $nonce, string $key): string\nEncrypt a message without authentication',
	'sodium_crypto_stream': '(int $length, string $nonce, string $key): string\nGenerate a deterministic sequence of bytes from a seed',
	'sodium_hex2bin': '(string $string, string $ignore = ""): string\nDecodes a hexadecimally encoded binary string',
	'sodium_increment': '(string $string): void\nIncrement large number',
	'sodium_memcmp': '(string $string1, string $string2): int\nTest for equality in constant-time',
	'sodium_memzero': '(string $string): void\nOverwrite a string with NUL characters',
	'sodium_pad': '(string $string, int $block_size): string\nAdd padding data',
	'sodium_unpad': '(string $string, int $block_size): string\nRemove padding data',
	'ob_tidyhandler': '(string $input, int $mode = ?): string\nob_start callback function to repair the buffer',
	'tidy_access_count': '(tidy $tidy): int\nReturns the Number of Tidy accessibility warnings encountered for specified document',
	'tidy_config_count': '(tidy $tidy): int\nReturns the Number of Tidy configuration errors encountered for specified document',
	'tidy_error_count': '(tidy $tidy): int\nReturns the Number of Tidy errors encountered for specified document',
	'tidy_get_output': '(tidy $tidy): string\nReturn a string representing the parsed tidy markup',
	'tidy_warning_count': '(tidy $tidy): int\nReturns the Number of Tidy warnings encountered for specified document',
	'tidy::body': '(): tidyNode|null\nReturns a tidyNode object starting from the ltbodygt tag of the tidy parse tree',
	'tidy_get_body': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the ltbodygt tag of the tidy parse tree',
	'tidy::cleanRepair': '(): bool\nExecute configured cleanup and repair operations on parsed markup',
	'tidy_clean_repair': '(tidy $tidy): bool\nExecute configured cleanup and repair operations on parsed markup',
	'tidy::diagnose': '(): bool\nRun configured diagnostics on parsed and repaired markup',
	'tidy_diagnose': '(tidy $tidy): bool\nRun configured diagnostics on parsed and repaired markup',
	'tidy_get_error_buffer': '(tidy $tidy): string|false\nReturn warnings and errors which occurred parsing the specified document',
	'tidy::getConfig': '(): array\nGet current Tidy configuration',
	'tidy_get_config': '(tidy $tidy): array\nGet current Tidy configuration',
	'tidy::getHtmlVer': '(): int\nGet the Detected HTML version for the specified document',
	'tidy_get_html_ver': '(tidy $tidy): int\nGet the Detected HTML version for the specified document',
	'tidy::getOpt': '(string $option): string|int|bool\nReturns the value of the specified configuration option for the tidy document',
	'tidy_getopt': '(tidy $tidy, string $option): string|int|bool\nReturns the value of the specified configuration option for the tidy document',
	'tidy::getOptDoc': '(string $option): string|false\nReturns the documentation for the given option name',
	'tidy_get_opt_doc': '(tidy $tidy, string $option): string|false\nReturns the documentation for the given option name',
	'tidy::getRelease': '(): string\nGet release date (version) for Tidy library',
	'tidy_get_release': '(): string\nGet release date (version) for Tidy library',
	'tidy::getStatus': '(): int\nGet status of specified document',
	'tidy_get_status': '(tidy $tidy): int\nGet status of specified document',
	'tidy::head': '(): tidyNode|null\nReturns a tidyNode object starting from the ltheadgt tag of the tidy parse tree',
	'tidy_get_head': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the ltheadgt tag of the tidy parse tree',
	'tidy::html': '(): tidyNode|null\nReturns a tidyNode object starting from the lthtmlgt tag of the tidy parse tree',
	'tidy_get_html': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object starting from the lthtmlgt tag of the tidy parse tree',
	'tidy::isXhtml': '(): bool\nIndicates if the document is a XHTML document',
	'tidy_is_xhtml': '(tidy $tidy): bool\nIndicates if the document is a XHTML document',
	'tidy::isXml': '(): bool\nIndicates if the document is a generic (non HTML/XHTML) XML document',
	'tidy_is_xml': '(tidy $tidy): bool\nIndicates if the document is a generic (non HTML/XHTML) XML document',
	'tidy::parseFile': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): bool\nParse markup in file or URI',
	'tidy_parse_file': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): tidy|false\nParse markup in file or URI',
	'tidy::parseString': '(string $string, array|string|null $config = null, string|null $encoding = null): bool\nParse a document stored in a string',
	'tidy_parse_string': '(string $string, array|string|null $config = null, string|null $encoding = null): tidy|false\nParse a document stored in a string',
	'tidy::repairFile': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
	'tidy_repair_file': '(string $filename, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false): string|false\nRepair a file and return it as a string',
	'tidy::repairString': '(string $string, array|string|null $config = null, string|null $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
	'tidy_repair_string': '(string $string, array|string|null $config = null, string|null $encoding = null): string|false\nRepair a string using an optionally provided configuration file',
	'tidy::root': '(): tidyNode|null\nReturns a tidyNode object representing the root of the tidy parse tree',
	'tidy_get_root': '(tidy $tidy): tidyNode|null\nReturns a tidyNode object representing the root of the tidy parse tree',
	'tidyNode::getNextSibling': '(): tidyNode|null\nReturns the next sibling node of the current node',
	'tidyNode::getParent': '(): tidyNode|null\nReturns the parent node of the current node',
	'tidyNode::getPreviousSibling': '(): tidyNode|null\nReturns the previous sibling node of the current node',
	'tidyNode::hasChildren': '(): bool\nChecks if a node has children',
	'tidyNode::hasSiblings': '(): bool\nChecks if a node has siblings',
	'tidyNode::isAsp': '(): bool\nChecks if this node is ASP',
	'tidyNode::isComment': '(): bool\nChecks if a node represents a comment',
	'tidyNode::isHtml': '(): bool\nChecks if a node is an element node',
	'tidyNode::isJste': '(): bool\nChecks if this node is JSTE',
	'tidyNode::isPhp': '(): bool\nChecks if a node is PHP',
	'tidyNode::isText': '(): bool\nChecks if a node represents text (no markup)',
	'odbc_autocommit': '(Odbc\\Connection $odbc, bool|null $enable = null): int|bool\nToggle autocommit behaviour',
	'odbc_binmode': '(Odbc\\Result $statement, int $mode): true\nHandling of binary column data',
	'odbc_close_all': '(): void\nClose all ODBC connections',
	'odbc_close': '(Odbc\\Connection $odbc): void\nClose an ODBC connection',
	'odbc_columnprivileges': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table, string $column): Odbc\\Result|false\nLists columns and associated privileges for the given table',
	'odbc_columns': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $table = null, string|null $column = null): Odbc\\Result|false\nLists the column names in specified tables',
	'odbc_commit': '(Odbc\\Connection $odbc): bool\nCommit an ODBC transaction',
	'odbc_connect': '(string $dsn, string|null $user = null, string|null $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nConnect to a datasource',
	'odbc_connection_string_is_quoted': '(string $str): bool\nDetermines if an ODBC connection string value is quoted',
	'odbc_connection_string_quote': '(string $str): string\nQuotes an ODBC connection string value',
	'odbc_connection_string_should_quote': '(string $str): bool\nDetermines if an ODBC connection string value should be quoted',
	'odbc_cursor': '(Odbc\\Result $statement): string|false\nGet cursorname',
	'odbc_data_source': '(Odbc\\Connection $odbc, int $fetch_type): array|null|false\nReturns information about available DSNs',
	'odbc_do': 'Alias of odbc_exec',
	'odbc_error': '(Odbc\\Connection|null $odbc = null): string\nGet the last error code',
	'odbc_errormsg': '(Odbc\\Connection|null $odbc = null): string\nGet the last error message',
	'odbc_exec': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nDirectly execute an SQL statement',
	'odbc_execute': '(Odbc\\Result $statement, array $params = []): bool\nExecute a prepared statement',
	'odbc_fetch_array': '(Odbc\\Result $statement, int|null $row = null): array|false\nFetch a result row as an associative array',
	'odbc_fetch_into': '(Odbc\\Result $statement, array $array, int|null $row = null): int|false\nFetch one result row into array',
	'odbc_fetch_object': '(Odbc\\Result $statement, int|null $row = null): stdClass|false\nFetch a result row as an object',
	'odbc_fetch_row': '(Odbc\\Result $statement, int|null $row = null): bool\nFetch a row',
	'odbc_field_len': '(Odbc\\Result $statement, int $field): int|false\nGet the length (precision) of a field',
	'odbc_field_name': '(Odbc\\Result $statement, int $field): string|false\nGet the columnname',
	'odbc_field_num': '(Odbc\\Result $statement, string $field): int|false\nReturn column number',
	'odbc_field_precision': 'Alias of odbc_field_len',
	'odbc_field_scale': '(Odbc\\Result $statement, int $field): int|false\nGet the scale of a field',
	'odbc_field_type': '(Odbc\\Result $statement, int $field): string|false\nDatatype of a field',
	'odbc_foreignkeys': '(Odbc\\Connection $odbc, string|null $pk_catalog, string $pk_schema, string $pk_table, string $fk_catalog, string $fk_schema, string $fk_table): Odbc\\Result|false\nRetrieves a list of foreign keys',
	'odbc_free_result': '(Odbc\\Result $statement): true\nFree objects associated with a result',
	'odbc_gettypeinfo': '(Odbc\\Connection $odbc, int $data_type = ?): Odbc\\Result|false\nRetrieves information about data types supported by the data source',
	'odbc_longreadlen': '(Odbc\\Result $statement, int $length): true\nHandling of LONG columns',
	'odbc_next_result': '(Odbc\\Result $statement): bool\nChecks if multiple results are available',
	'odbc_num_fields': '(Odbc\\Result $statement): int\nNumber of columns in a result',
	'odbc_num_rows': '(Odbc\\Result $statement): int\nNumber of rows in a result',
	'odbc_pconnect': '(string $dsn, string|null $user = null, string|null $password = null, int $cursor_option = SQL_CUR_USE_DRIVER): Odbc\\Connection|false\nOpen a persistent database connection',
	'odbc_prepare': '(Odbc\\Connection $odbc, string $query): Odbc\\Result|false\nPrepares a statement for execution',
	'odbc_primarykeys': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table): Odbc\\Result|false\nGets the primary keys for a table',
	'odbc_procedurecolumns': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $procedure = null, string|null $column = null): Odbc\\Result|false\nRetrieve information about parameters to procedures',
	'odbc_procedures': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $procedure = null): Odbc\\Result|false\nGet the list of procedures stored in a specific data source',
	'odbc_result_all': '(Odbc\\Result $statement, string $format = ""): int|false\nPrint result as HTML table',
	'odbc_result': '(Odbc\\Result $statement, string|int $field): string|bool|null\nGet result data',
	'odbc_rollback': '(Odbc\\Connection $odbc): bool\nRollback a transaction',
	'odbc_setoption': '(Odbc\\Connection|Odbc\\Result $odbc, int $which, int $option, int $value): bool\nAdjust ODBC settings',
	'odbc_specialcolumns': '(Odbc\\Connection $odbc, int $type, string|null $catalog, string $schema, string $table, int $scope, int $nullable): Odbc\\Result|false\nRetrieves special columns',
	'odbc_statistics': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table, int $unique, int $accuracy): Odbc\\Result|false\nRetrieve statistics about a table',
	'odbc_tableprivileges': '(Odbc\\Connection $odbc, string|null $catalog, string $schema, string $table): Odbc\\Result|false\nLists tables and the privileges associated with each table',
	'odbc_tables': '(Odbc\\Connection $odbc, string|null $catalog = null, string|null $schema = null, string|null $table = null, string|null $types = null): Odbc\\Result|false\nGet the list of table names stored in a specific data source',
	'xml_error_string': '(int $error_code): string|null\nGet XML parser error string',
	'xml_get_current_byte_index': '(XMLParser $parser): int\nGet current byte index for an XML parser',
	'xml_get_current_column_number': '(XMLParser $parser): int\nGet current column number for an XML parser',
	'xml_get_current_line_number': '(XMLParser $parser): int\nGet current line number for an XML parser',
	'xml_get_error_code': '(XMLParser $parser): int\nGet XML parser error code',
	'xml_parse_into_struct': '(XMLParser $parser, string $data, array $values, array $index = null): int|false\nParse XML data into an array structure',
	'xml_parse': '(XMLParser $parser, string $data, bool $is_final = false): int\nStart parsing an XML document',
	'xml_parser_create_ns': '(string|null $encoding = null, string $separator = ":"): XMLParser\nCreate an XML parser with namespace support',
	'xml_parser_create': '(string|null $encoding = null): XMLParser\nCreate an XML parser',
	'xml_parser_free': '(XMLParser $parser): bool\nFree an XML parser',
	'xml_parser_get_option': '(XMLParser $parser, int $option): string|int|bool\nGet options from an XML parser',
	'xml_parser_set_option': '(XMLParser $parser, int $option, string|int|bool $value): bool\nSet options in an XML parser',
	'xml_set_character_data_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up character data handler',
	'xml_set_default_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up default handler',
	'xml_set_element_handler': '(XMLParser $parser, callable|string|null $start_handler, callable|string|null $end_handler): true\nSet up start and end element handlers',
	'xml_set_end_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up end namespace declaration handler',
	'xml_set_external_entity_ref_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up external entity reference handler',
	'xml_set_notation_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up notation declaration handler',
	'xml_set_object': '(XMLParser $parser, object $object): true\nUse XML Parser within an object',
	'xml_set_processing_instruction_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up processing instruction (PI) handler',
	'xml_set_start_namespace_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up start namespace declaration handler',
	'xml_set_unparsed_entity_decl_handler': '(XMLParser $parser, callable|string|null $handler): true\nSet up unparsed entity declaration handler',
	'XMLReader::close': '(): true\nClose the XMLReader input',
	'XMLReader::expand': '(DOMNode|null $baseNode = null): DOMNode|false\nReturns a copy of the current node as a DOM object',
	'XMLReader::fromStream': '(resource $stream, string|null $encoding = null, int $flags = ?, string|null $documentUri = null): static\nCreates an XMLReader from a stream to read from',
	'XMLReader::fromString': '(string $source, string|null $encoding = null, int $flags = ?): static\nCreates an XMLReader from an XML string',
	'XMLReader::fromUri': '(string $uri, string|null $encoding = null, int $flags = ?): static\nCreates an XMLReader from a URI to read from',
	'XMLReader::getAttribute': '(string $name): string|null\nGet the value of a named attribute',
	'XMLReader::getAttributeNo': '(int $index): string|null\nGet the value of an attribute by index',
	'XMLReader::getAttributeNs': '(string $name, string $namespace): string|null\nGet the value of an attribute by localname and URI',
	'XMLReader::getParserProperty': '(int $property): bool\nIndicates if specified property has been set',
	'XMLReader::isValid': '(): bool\nIndicates if the parsed document is valid',
	'XMLReader::lookupNamespace': '(string $prefix): string|null\nLookup namespace for a prefix',
	'XMLReader::moveToAttribute': '(string $name): bool\nMove cursor to a named attribute',
	'XMLReader::moveToAttributeNo': '(int $index): bool\nMove cursor to an attribute by index',
	'XMLReader::moveToAttributeNs': '(string $name, string $namespace): bool\nMove cursor to a named attribute',
	'XMLReader::moveToElement': '(): bool\nPosition cursor on the parent Element of current Attribute',
	'XMLReader::moveToFirstAttribute': '(): bool\nPosition cursor on the first Attribute',
	'XMLReader::moveToNextAttribute': '(): bool\nPosition cursor on the next Attribute',
	'XMLReader::next': '(string|null $name = null): bool\nMove cursor to next node skipping all subtrees',
	'XMLReader::open': '(string $uri, string|null $encoding = null, int $flags = ?): XMLReader\nSet the URI containing the XML to parse',
	'XMLReader::open': '(string $uri, string|null $encoding = null, int $flags = ?): bool\nSet the URI containing the XML to parse',
	'XMLReader::read': '(): bool\nMove to next node in document',
	'XMLReader::readInnerXml': '(): string\nRetrieve XML from current node',
	'XMLReader::readOuterXml': '(): string\nRetrieve XML from current node, including itself',
	'XMLReader::readString': '(): string\nReads the contents of the current node as a string',
	'XMLReader::setParserProperty': '(int $property, bool $value): bool\nSet parser options',
	'XMLReader::setRelaxNGSchema': '(string|null $filename): bool\nSet the filename or URI for a RelaxNG Schema',
	'XMLReader::setRelaxNGSchemaSource': '(string|null $source): bool\nSet the data containing a RelaxNG Schema',
	'XMLReader::setSchema': '(string|null $filename): bool\nValidate document against XSD',
	'XMLReader::XML': '(string $source, string|null $encoding = null, int $flags = ?): XMLReader\nSet the data containing the XML to parse',
	'XMLReader::XML': '(string $source, string|null $encoding = null, int $flags = ?): bool\nSet the data containing the XML to parse',
	'XMLWriter::endAttribute': '(): bool\nEnd attribute',
	'xmlwriter_end_attribute': '(XMLWriter $writer): bool\nEnd attribute',
	'XMLWriter::endCdata': '(): bool\nEnd current CDATA',
	'xmlwriter_end_cdata': '(XMLWriter $writer): bool\nEnd current CDATA',
	'XMLWriter::endComment': '(): bool\nCreate end comment',
	'xmlwriter_end_comment': '(XMLWriter $writer): bool\nCreate end comment',
	'XMLWriter::endDocument': '(): bool\nEnd current document',
	'xmlwriter_end_document': '(XMLWriter $writer): bool\nEnd current document',
	'XMLWriter::endDtd': '(): bool\nEnd current DTD',
	'xmlwriter_end_dtd': '(XMLWriter $writer): bool\nEnd current DTD',
	'XMLWriter::endDtdAttlist': '(): bool\nEnd current DTD AttList',
	'xmlwriter_end_dtd_attlist': '(XMLWriter $writer): bool\nEnd current DTD AttList',
	'XMLWriter::endDtdElement': '(): bool\nEnd current DTD element',
	'xmlwriter_end_dtd_element': '(XMLWriter $writer): bool\nEnd current DTD element',
	'XMLWriter::endDtdEntity': '(): bool\nEnd current DTD Entity',
	'xmlwriter_end_dtd_entity': '(XMLWriter $writer): bool\nEnd current DTD Entity',
	'XMLWriter::endElement': '(): bool\nEnd current element',
	'xmlwriter_end_element': '(XMLWriter $writer): bool\nEnd current element',
	'XMLWriter::endPi': '(): bool\nEnd current PI',
	'xmlwriter_end_pi': '(XMLWriter $writer): bool\nEnd current PI',
	'XMLWriter::flush': '(bool $empty = true): string|int\nFlush current buffer',
	'xmlwriter_flush': '(XMLWriter $writer, bool $empty = true): string|int\nFlush current buffer',
	'XMLWriter::fullEndElement': '(): bool\nEnd current element',
	'xmlwriter_full_end_element': '(XMLWriter $writer): bool\nEnd current element',
	'XMLWriter::openMemory': '(): bool\nCreate new xmlwriter using memory for string output',
	'xmlwriter_open_memory': '(): XMLWriter|false\nCreate new xmlwriter using memory for string output',
	'XMLWriter::openUri': '(string $uri): bool\nCreate new xmlwriter using source uri for output',
	'xmlwriter_open_uri': '(string $uri): XMLWriter|false\nCreate new xmlwriter using source uri for output',
	'XMLWriter::outputMemory': '(bool $flush = true): string\nReturns current buffer',
	'xmlwriter_output_memory': '(XMLWriter $writer, bool $flush = true): string\nReturns current buffer',
	'XMLWriter::setIndent': '(bool $enable): bool\nToggle indentation on/off',
	'xmlwriter_set_indent': '(XMLWriter $writer, bool $enable): bool\nToggle indentation on/off',
	'XMLWriter::setIndentString': '(string $indentation): bool\nSet string used for indenting',
	'xmlwriter_set_indent_string': '(XMLWriter $writer, string $indentation): bool\nSet string used for indenting',
	'XMLWriter::startAttribute': '(string $name): bool\nCreate start attribute',
	'xmlwriter_start_attribute': '(XMLWriter $writer, string $name): bool\nCreate start attribute',
	'XMLWriter::startAttributeNs': '(string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced attribute',
	'xmlwriter_start_attribute_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced attribute',
	'XMLWriter::startCdata': '(): bool\nCreate start CDATA tag',
	'xmlwriter_start_cdata': '(XMLWriter $writer): bool\nCreate start CDATA tag',
	'XMLWriter::startComment': '(): bool\nCreate start comment',
	'xmlwriter_start_comment': '(XMLWriter $writer): bool\nCreate start comment',
	'XMLWriter::startDocument': '(string|null $version = "1.0", string|null $encoding = null, string|null $standalone = null): bool\nCreate document tag',
	'xmlwriter_start_document': '(XMLWriter $writer, string|null $version = "1.0", string|null $encoding = null, string|null $standalone = null): bool\nCreate document tag',
	'XMLWriter::startDtd': '(string $qualifiedName, string|null $publicId = null, string|null $systemId = null): bool\nCreate start DTD tag',
	'xmlwriter_start_dtd': '(XMLWriter $writer, string $qualifiedName, string|null $publicId = null, string|null $systemId = null): bool\nCreate start DTD tag',
	'XMLWriter::startDtdAttlist': '(string $name): bool\nCreate start DTD AttList',
	'xmlwriter_start_dtd_attlist': '(XMLWriter $writer, string $name): bool\nCreate start DTD AttList',
	'XMLWriter::startDtdElement': '(string $qualifiedName): bool\nCreate start DTD element',
	'xmlwriter_start_dtd_element': '(XMLWriter $writer, string $qualifiedName): bool\nCreate start DTD element',
	'XMLWriter::startDtdEntity': '(string $name, bool $isParam): bool\nCreate start DTD Entity',
	'xmlwriter_start_dtd_entity': '(XMLWriter $writer, string $name, bool $isParam): bool\nCreate start DTD Entity',
	'XMLWriter::startElement': '(string $name): bool\nCreate start element tag',
	'xmlwriter_start_element': '(XMLWriter $writer, string $name): bool\nCreate start element tag',
	'XMLWriter::startElementNs': '(string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced element tag',
	'xmlwriter_start_element_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace): bool\nCreate start namespaced element tag',
	'XMLWriter::startPi': '(string $target): bool\nCreate start PI tag',
	'xmlwriter_start_pi': '(XMLWriter $writer, string $target): bool\nCreate start PI tag',
	'XMLWriter::text': '(string $content): bool\nWrite text',
	'xmlwriter_text': '(XMLWriter $writer, string $content): bool\nWrite text',
	'XMLWriter::toMemory': '(): static\nCreate new XMLWriter using memory for string output',
	'XMLWriter::toStream': '(resource $stream): static\nCreate new XMLWriter using a stream for output',
	'XMLWriter::toUri': '(string $uri): static\nCreate new XMLWriter using a URI for output',
	'XMLWriter::writeAttribute': '(string $name, string $value): bool\nWrite full attribute',
	'xmlwriter_write_attribute': '(XMLWriter $writer, string $name, string $value): bool\nWrite full attribute',
	'XMLWriter::writeAttributeNs': '(string|null $prefix, string $name, string|null $namespace, string $value): bool\nWrite full namespaced attribute',
	'xmlwriter_write_attribute_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace, string $value): bool\nWrite full namespaced attribute',
	'XMLWriter::writeCdata': '(string $content): bool\nWrite full CDATA tag',
	'xmlwriter_write_cdata': '(XMLWriter $writer, string $content): bool\nWrite full CDATA tag',
	'XMLWriter::writeComment': '(string $content): bool\nWrite full comment tag',
	'xmlwriter_write_comment': '(XMLWriter $writer, string $content): bool\nWrite full comment tag',
	'XMLWriter::writeDtd': '(string $name, string|null $publicId = null, string|null $systemId = null, string|null $content = null): bool\nWrite full DTD tag',
	'xmlwriter_write_dtd': '(XMLWriter $writer, string $name, string|null $publicId = null, string|null $systemId = null, string|null $content = null): bool\nWrite full DTD tag',
	'XMLWriter::writeDtdAttlist': '(string $name, string $content): bool\nWrite full DTD AttList tag',
	'xmlwriter_write_dtd_attlist': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD AttList tag',
	'XMLWriter::writeDtdElement': '(string $name, string $content): bool\nWrite full DTD element tag',
	'xmlwriter_write_dtd_element': '(XMLWriter $writer, string $name, string $content): bool\nWrite full DTD element tag',
	'XMLWriter::writeDtdEntity': '(string $name, string $content, bool $isParam = false, string|null $publicId = null, string|null $systemId = null, string|null $notationData = null): bool\nWrite full DTD Entity tag',
	'xmlwriter_write_dtd_entity': '(XMLWriter $writer, string $name, string $content, bool $isParam = false, string|null $publicId = null, string|null $systemId = null, string|null $notationData = null): bool\nWrite full DTD Entity tag',
	'XMLWriter::writeElement': '(string $name, string|null $content = null): bool\nWrite full element tag',
	'xmlwriter_write_element': '(XMLWriter $writer, string $name, string|null $content = null): bool\nWrite full element tag',
	'XMLWriter::writeElementNs': '(string|null $prefix, string $name, string|null $namespace, string|null $content = null): bool\nWrite full namespaced element tag',
	'xmlwriter_write_element_ns': '(XMLWriter $writer, string|null $prefix, string $name, string|null $namespace, string|null $content = null): bool\nWrite full namespaced element tag',
	'XMLWriter::writePi': '(string $target, string $content): bool\nWrites a PI',
	'xmlwriter_write_pi': '(XMLWriter $writer, string $target, string $content): bool\nWrites a PI',
	'XMLWriter::writeRaw': '(string $content): bool\nWrite a raw XML text',
	'xmlwriter_write_raw': '(XMLWriter $writer, string $content): bool\nWrite a raw XML text',
	'XSLTProcessor::getParameter': '(string $namespace, string $name): string|false\nGet value of a parameter',
	'XSLTProcessor::getSecurityPrefs': '(): int\nGet security preferences',
	'XSLTProcessor::hasExsltSupport': '(): bool\nDetermine if PHP has EXSLT support',
	'XSLTProcessor::importStylesheet': '(object $stylesheet): bool\nImport stylesheet',
	'XSLTProcessor::registerPHPFunctionNS': '(string $namespaceURI, string $name, callable $callable): void\nRegister a PHP function as namespaced XSLT function',
	'XSLTProcessor::registerPHPFunctions': '(array|string|null $functions = null): void\nEnables the ability to use PHP functions as XSLT functions',
	'XSLTProcessor::removeParameter': '(string $namespace, string $name): bool\nRemove parameter',
	'XSLTProcessor::setParameter': '(string $namespace, string $name, string $value): bool\nSet value for a parameter',
	'XSLTProcessor::setParameter': '(string $namespace, array $options): bool\nSet value for a parameter',
	'XSLTProcessor::setProfiling': '(string|null $filename): true\nSets profiling output file',
	'XSLTProcessor::setSecurityPrefs': '(int $preferences): int\nSet security preferences',
	'XSLTProcessor::transformToDoc': '(object $document, string|null $returnClass = null): object|false\nTransform to a document',
	'XSLTProcessor::transformToUri': '(object $document, string $uri): int\nTransform to URI',
	'XSLTProcessor::transformToXml': '(object $document): string|null|false\nTransform to XML',
	'zip_close': '(resource $zip): void\nClose a ZIP file archive',
	'zip_entry_close': '(resource $zip_entry): bool\nClose a directory entry',
	'zip_entry_compressedsize': '(resource $zip_entry): int|false\nRetrieve the compressed size of a directory entry',
	'zip_entry_compressionmethod': '(resource $zip_entry): string|false\nRetrieve the compression method of a directory entry',
	'zip_entry_filesize': '(resource $zip_entry): int|false\nRetrieve the actual file size of a directory entry',
	'zip_entry_name': '(resource $zip_entry): string|false\nRetrieve the name of a directory entry',
	'zip_entry_open': '(resource $zip_dp, resource $zip_entry, string $mode = "rb"): bool\nOpen a directory entry for reading',
	'zip_entry_read': '(resource $zip_entry, int $len = 1024): string|false\nRead from an open directory entry',
	'zip_open': '(string $filename): resource|int|false\nOpen a ZIP file archive',
	'zip_read': '(resource $zip): resource|false\nRead next entry in a ZIP file archive',
	'ZipArchive::addEmptyDir': '(string $dirname, int $flags = ?): bool\nAdd a new directory',
	'ZipArchive::addFile': '(string $filepath, string $entryname = "", int $start = ?, int $length = ZipArchive::LENGTH_TO_END, int $flags = ZipArchive::FL_OVERWRITE): bool\nAdds a file to a ZIP archive from the given path',
	'ZipArchive::addFromString': '(string $name, string $content, int $flags = ZipArchive::FL_OVERWRITE): bool\nAdd a file to a ZIP archive using its contents',
	'ZipArchive::addGlob': '(string $pattern, int $flags = ?, array $options = []): array|false\nAdd files from a directory by glob pattern',
	'ZipArchive::addPattern': '(string $pattern, string $path = ".", array $options = []): array|false\nAdd files from a directory by PCRE pattern',
	'ZipArchive::clearError': '(): void\nClear the status error message, system and/or zip messages',
	'ZipArchive::close': '(): bool\nClose the active archive (opened or newly created)',
	'ZipArchive::count': '(): int\nCounts the number of files in the archive',
	'ZipArchive::deleteIndex': '(int $index): bool\nDelete an entry in the archive using its index',
	'ZipArchive::deleteName': '(string $name): bool\nDelete an entry in the archive using its name',
	'ZipArchive::extractTo': '(string $pathto, array|string|null $files = null): bool\nExtract the archive contents',
	'ZipArchive::getArchiveComment': '(int $flags = ?): string|false\nReturns the Zip archive comment',
	'ZipArchive::getArchiveFlag': '(int $flag, int $flags = ?): int\nReturns the value of a Zip archive global flag',
	'ZipArchive::getCommentIndex': '(int $index, int $flags = ?): string|false\nReturns the comment of an entry using the entry index',
	'ZipArchive::getCommentName': '(string $name, int $flags = ?): string|false\nReturns the comment of an entry using the entry name',
	'ZipArchive::getExternalAttributesIndex': '(int $index, int $opsys, int $attr, int $flags = ?): bool\nRetrieve the external attributes of an entry defined by its index',
	'ZipArchive::getExternalAttributesName': '(string $name, int $opsys, int $attr, int $flags = ?): bool\nRetrieve the external attributes of an entry defined by its name',
	'ZipArchive::getFromIndex': '(int $index, int $len = ?, int $flags = ?): string|false\nReturns the entry contents using its index',
	'ZipArchive::getFromName': '(string $name, int $len = ?, int $flags = ?): string|false\nReturns the entry contents using its name',
	'ZipArchive::getNameIndex': '(int $index, int $flags = ?): string|false\nReturns the name of an entry using its index',
	'ZipArchive::getStatusString': '(): string\nReturns the status error message, system and/or zip messages',
	'ZipArchive::getStream': '(string $name): resource|false\nGet a file handler to the entry defined by its name (read only)',
	'ZipArchive::getStreamIndex': '(int $index, int $flags = ?): resource|false\nGet a file handler to the entry defined by its index (read only)',
	'ZipArchive::getStreamName': '(string $name, int $flags = ?): resource|false\nGet a file handler to the entry defined by its name (read only)',
	'ZipArchive::isCompressionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a compression method is supported by libzip',
	'ZipArchive::isEncryptionMethodSupported': '(int $method, bool $enc = true): bool\nCheck if a encryption method is supported by libzip',
	'ZipArchive::locateName': '(string $name, int $flags = ?): int|false\nReturns the index of the entry in the archive',
	'ZipArchive::open': '(string $filename, int $flags = ?): bool|int\nOpen a ZIP file archive',
	'ZipArchive::registerCancelCallback': '(callable $callback): bool\nRegister a callback to allow cancellation during archive close.',
	'ZipArchive::registerProgressCallback': '(float $rate, callable $callback): bool\nRegister a callback to provide updates during archive close.',
	'ZipArchive::renameIndex': '(int $index, string $new_name): bool\nRenames an entry defined by its index',
	'ZipArchive::renameName': '(string $name, string $new_name): bool\nRenames an entry defined by its name',
	'ZipArchive::replaceFile': '(string $filepath, int $index, int $start = ?, int $length = ZipArchive::LENGTH_TO_END, int $flags = ?): bool\nReplace file in ZIP archive with a given path',
	'ZipArchive::setArchiveComment': '(string $comment): bool\nSet the comment of a ZIP archive',
	'ZipArchive::setArchiveFlag': '(int $flag, int $value): bool\nSet a global flag of a ZIP archive',
	'ZipArchive::setCommentIndex': '(int $index, string $comment): bool\nSet the comment of an entry defined by its index',
	'ZipArchive::setCommentName': '(string $name, string $comment): bool\nSet the comment of an entry defined by its name',
	'ZipArchive::setCompressionIndex': '(int $index, int $method, int $compflags = ?): bool\nSet the compression method of an entry defined by its index',
	'ZipArchive::setCompressionName': '(string $name, int $method, int $compflags = ?): bool\nSet the compression method of an entry defined by its name',
	'ZipArchive::setEncryptionIndex': '(int $index, int $method, string|null $password = null): bool\nSet the encryption method of an entry defined by its index',
	'ZipArchive::setEncryptionName': '(string $name, int $method, string|null $password = null): bool\nSet the encryption method of an entry defined by its name',
	'ZipArchive::setExternalAttributesIndex': '(int $index, int $opsys, int $attr, int $flags = ?): bool\nSet the external attributes of an entry defined by its index',
	'ZipArchive::setExternalAttributesName': '(string $name, int $opsys, int $attr, int $flags = ?): bool\nSet the external attributes of an entry defined by its name',
	'ZipArchive::setMtimeIndex': '(int $index, int $timestamp, int $flags = ?): bool\nSet the modification time of an entry defined by its index',
	'ZipArchive::setMtimeName': '(string $name, int $timestamp, int $flags = ?): bool\nSet the modification time of an entry defined by its name',
	'ZipArchive::setPassword': '(string $password): bool\nSet the password for the active archive',
	'ZipArchive::statIndex': '(int $index, int $flags = ?): array|false\nGet the details of an entry defined by its index',
	'ZipArchive::statName': '(string $name, int $flags = ?): array|false\nGet the details of an entry defined by its name',
	'ZipArchive::unchangeAll': '(): bool\nUndo all changes done in the archive',
	'ZipArchive::unchangeArchive': '(): bool\nRevert all global changes done in the archive',
	'ZipArchive::unchangeIndex': '(int $index): bool\nRevert all changes done to an entry at the given index',
	'ZipArchive::unchangeName': '(string $name): bool\nRevert all changes done to an entry with the given name',
});

jush.api.php_fun = jush.api.lowercase_keys({
	'__construct': '(mixed ...$values)\nObject constructor',
	'__destruct': '()\nObject destructor',
	'__call': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in an object context',
	'__callStatic': '(string $name, array $arguments): mixed\nTriggered when invoking inaccessible methods in a static context',
	'__get': '(string $name): mixed\nUtilized for reading data from inaccessible properties',
	'__set': '(string $name, mixed $value): void\nRun when writing data to inaccessible properties',
	'__isset': '(string $name): bool\nTriggered by calling isset() or empty() on inaccessible properties',
	'__unset': '(string $name): void\nInvoked when unset() is used on inaccessible properties',
	'__sleep': '(): array\nCalled by serialize()',
	'__wakeup': '(): void\nCalled by unserialize()',
	'__serialize': '(): array\nCalled by serialize()',
	'__unserialize': '(array $data): void\nCalled by unserialize()',
	'__toString': '(): string\nDecide how to react when object is converted to a string',
	'__invoke': '(mixed ...$values): mixed\nCalled when a script tries to call an object as a function',
	'__set_state': '(array $properties): object\nCalled by var_export() result',
	'__clone': '(): void\nCalled after cloning',
	'__debugInfo': '(): array\nCalled by var_dump()',
});

jush.api.php_new = jush.api.lowercase_keys({
	'AllowDynamicProperties': 'Construct a new AllowDynamicProperties attribute instance',
	'Attribute': '(int $flags = Attribute::TARGET_ALL)\nConstruct a new Attribute instance',
	'Deprecated': '(string|null $message = null, string|null $since = null)\nConstruct a new Deprecated attribute instance',
	'Override': 'Construct a new Override attribute instance',
	'Closure': 'Constructor that disallows instantiation',
	'Error': '(string $message = "", int $code = ?, Throwable|null $previous = null)\nConstruct the error object',
	'ErrorException': '(string $message = "", int $code = ?, int $severity = E_ERROR, string|null $filename = null, int|null $line = null, Throwable|null $previous = null)\nConstructs the exception',
	'Exception': '(string $message = "", int $code = ?, Throwable|null $previous = null)\nConstruct the exception',
	'Fiber': '(callable $callback)\nCreates a new Fiber instance',
	'FiberError': 'Constructor to disallow direct instantiation',
	'InternalIterator': 'Private constructor to disallow direct instantiation',
	'ReturnTypeWillChange': 'Construct a new ReturnTypeWillChange attribute instance',
	'SensitiveParameter': 'Construct a new SensitiveParameter attribute instance',
	'SensitiveParameterValue': '(mixed $value)\nConstructs a new SensitiveParameterValue object',
	'WeakReference': 'Constructor that disallows instantiation',
	'ArgumentCountError': 'ArgumentCountError is thrown when too few arguments are passed to a user-defined function or method',
	'ArithmeticError': 'ArithmeticError is thrown when an error occurs while performing mathematical operations',
	'ArrayAccess': 'Interface to provide accessing objects as arrays',
	'AssertionError': 'AssertionError is thrown when an assertion made via assert fails',
	'BackedEnum': 'The BackedEnum interface is automatically applied to backed enumerations by the engine',
	'ClosedGeneratorException': 'A ClosedGeneratorException is thrown when trying to retrieve a value from a closed Generator',
	'CompileError': 'CompileError is thrown for some compilation errors, which formerly issued a fatal error',
	'Countable': 'Classes implementing Countable can be used with the count function',
	'DivisionByZeroError': 'DivisionByZeroError is thrown when an attempt is made to divide a number by zero',
	'Generator': 'Generator objects are returned from generators',
	'Iterator': 'Interface for external iterators or objects that can be iterated themselves internally',
	'IteratorAggregate': 'Interface to create an external Iterator',
	'ParseError': 'ParseError is thrown when an error occurs while parsing PHP code, such as when eval is called',
	'__PHP_Incomplete_Class': 'Created by unserialize when trying to unserialize an undefined class or a class that is not listed in the allowed_classes of unserialize\'s $options array',
	'RequestParseBodyException': 'A RequestParseBodyException is thrown in request_parse_body when the request body is invalid, according to the Content-Type header',
	'Serializable': 'Interface for customized serializing',
	'stdClass': 'A generic empty class with dynamic properties',
	'Stringable': 'The Stringable interface denotes a class as having a __toString() method',
	'Throwable': 'Throwable is the base interface for any object that can be thrown via a throw statement, including Error and Exception',
	'Traversable': 'Interface to detect if a class is traversable using foreach',
	'TypeError': 'A TypeError may be thrown when: The value being set for a class property does not match the property\'s corresponding declared type',
	'UnhandledMatchError': 'An UnhandledMatchError is thrown when the subject passed to a match expression is not handled by any arm of the match expression',
	'UnitEnum': 'The UnitEnum interface is automatically applied to all enumerations by the engine',
	'ValueError': 'A ValueError is thrown when the type of an argument is correct but the value of it is incorrect',
	'WeakMap': 'A WeakMap is map (or dictionary) that accepts objects as keys',
	'DateInterval': '(string $duration)\nCreates a new DateInterval object',
	'DatePeriod': '(DateTimeInterface $start, DateInterval $interval, int $recurrences, int $options = ?)\nCreates a new DatePeriod object',
	'DatePeriod': '(DateTimeInterface $start, DateInterval $interval, DateTimeInterface $end, int $options = ?)\nCreates a new DatePeriod object',
	'DateTime': '(string $datetime = "now", DateTimeZone|null $timezone = null)\nReturns new DateTime object',
	'DateError': 'Thrown when the timezone database is not found, or contains invalid data',
	'DateException': 'Parent class of Date/Time exceptions, for issues that come to light due to user input, or free form text arguments that need to be parsed',
	'DateInvalidOperationException': 'Thrown by DateTimeImmutable::sub and DateTime::sub when an unsupported operation is attempted',
	'DateInvalidTimeZoneException': 'Thrown when an incorrect value is passed to DateTimeZone::__construct',
	'DateMalformedIntervalStringException': 'Thrown when an invalid $duration argument is passed to DateInterval::__construct',
	'DateMalformedPeriodStringException': 'Thrown when an invalid $isostr argument is passed to DatePeriod::__construct',
	'DateMalformedStringException': 'Thrown when an invalid Date/Time string is detected',
	'DateObjectError': 'Thrown when one of the Date/Time classes has not been correctly initialised',
	'DateRangeError': 'Thrown by DateTime::getTimestamp, DateTimeImmutable::getTimestamp, and date_timestamp_get, on 32-bit platforms if the date object represents a date outside of the 32-bit signed range',
	'DateTimeImmutable': 'Representation of date and time',
	'DateTimeInterface': 'DateTimeInterface was created so that parameter, return, or property type declarations may accept either DateTimeImmutable or DateTime as a value',
	'DateTimeZone': 'Representation of time zone',
	'Directory': 'Instances of Directory are created by calling the dir function, not by the new operator',
	'HashContext': 'Private constructor to disallow direct instantiation',
	'JsonException': 'Exception thrown if JSON_THROW_ON_ERROR option is set for json_encode or json_decode',
	'JsonSerializable': 'Objects implementing JsonSerializable can customize their JSON representation when encoded with json_encode',
	'Random\\Engine\\Mt19937': '(int|null $seed = null, int $mode = MT_RAND_MT19937)\nConstructs a new Mt19937 engine',
	'Random\\Engine\\PcgOneseq128XslRr64': '(string|int|null $seed = null)\nConstructs a new PCG Oneseq 128 XSL RR 64 engine',
	'Random\\Engine\\Xoshiro256StarStar': '(string|int|null $seed = null)\nConstructs a new xoshiro256** engine',
	'Random\\Randomizer': '(Random\\Engine|null $engine = null)\nConstructs a new Randomizer',
	'Random\\BrokenRandomEngineError': 'Indicates that the used Random\\Engine is broken, e',
	'Random\\CryptoSafeEngine': 'A marker interface indicating that the Random\\Engine returns cryptographically secure randomness',
	'Random\\Engine\\Secure': 'Generates cryptographically secure randomness using the operating system’s CSPRNG',
	'Random\\Engine': 'A Random\\Engine provides a low-level source of randomness by returning random bytes that are consumed by high-level APIs to perform their operations',
	'Random\\RandomError': 'The base class for Errors that occur during generation or use of randomness',
	'Random\\RandomException': 'The base class for Exceptions that occur during generation or use of randomness',
	'ReflectionAttribute': 'Private constructor to disallow direct instantiation',
	'ReflectionClass': '(object|string $objectOrClass)\nConstructs a ReflectionClass',
	'ReflectionClassConstant': '(object|string $class, string $constant)\nConstructs a ReflectionClassConstant',
	'ReflectionConstant': '(string $name)\nConstructs a ReflectionConstant',
	'ReflectionEnum': '(object|string $objectOrClass)\nInstantiates a ReflectionEnum object',
	'ReflectionEnumBackedCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumBackedCase object',
	'ReflectionEnumUnitCase': '(object|string $class, string $constant)\nInstantiates a ReflectionEnumUnitCase object',
	'ReflectionExtension': '(string $name)\nConstructs a ReflectionExtension',
	'ReflectionFiber': '(Fiber $fiber)\nConstructs a ReflectionFiber object',
	'ReflectionFunction': '(Closure|string $function)\nConstructs a ReflectionFunction object',
	'ReflectionGenerator': '(Generator $generator)\nConstructs a ReflectionGenerator object',
	'ReflectionMethod': '(object|string $objectOrMethod, string $method)\nConstructs a ReflectionMethod',
	'ReflectionMethod': '(string $classMethod)\nConstructs a ReflectionMethod',
	'ReflectionObject': '(object $object)\nConstructs a ReflectionObject',
	'ReflectionParameter': '(string|array|object $function, int|string $param)\nConstruct',
	'ReflectionProperty': '(object|string $class, string $property)\nConstruct a ReflectionProperty object',
	'ReflectionReference': 'Private constructor to disallow direct instantiation',
	'ReflectionZendExtension': '(string $name)\nConstructs a ReflectionZendExtension object',
	'Reflection': 'The reflection class',
	'ReflectionException': 'The ReflectionException class',
	'ReflectionFunctionAbstract': 'A parent class to ReflectionFunction, read its description for details',
	'ReflectionType': 'The ReflectionType class reports information about a function\'s parameter/return type or a class\'s property type',
	'Reflector': 'Reflector is an interface implemented by all exportable Reflection classes',
	'AppendIterator': 'Constructs an AppendIterator',
	'ArrayIterator': '(array|object $array = [], int $flags = ?)\nConstruct an ArrayIterator',
	'ArrayObject': '(array|object $array = [], int $flags = ?, string $iteratorClass = ArrayIterator::class)\nConstruct a new array object',
	'CachingIterator': '(Iterator $iterator, int $flags = CachingIterator::CALL_TOSTRING)\nConstruct a new CachingIterator object for the iterator',
	'CallbackFilterIterator': '(Iterator $iterator, callable $callback)\nCreate a filtered iterator from another iterator',
	'DirectoryIterator': '(string $directory)\nConstructs a new directory iterator from a path',
	'FilesystemIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO | FilesystemIterator::SKIP_DOTS)\nConstructs a new filesystem iterator',
	'FilterIterator': '(Iterator $iterator)\nConstruct a filterIterator',
	'GlobIterator': '(string $pattern, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstruct a directory using glob',
	'InfiniteIterator': '(Iterator $iterator)\nConstructs an InfiniteIterator',
	'IteratorIterator': '(Traversable $iterator, string|null $class = null)\nCreate an iterator from anything that is traversable',
	'LimitIterator': '(Iterator $iterator, int $offset = ?, int $limit = -1)\nConstruct a LimitIterator',
	'MultipleIterator': '(int $flags = MultipleIterator::MIT_NEED_ALL | MultipleIterator::MIT_KEYS_NUMERIC)\nConstructs a new MultipleIterator',
	'NoRewindIterator': '(Iterator $iterator)\nConstruct a NoRewindIterator',
	'ParentIterator': '(RecursiveIterator $iterator)\nConstructs a ParentIterator',
	'RecursiveCachingIterator': '(Iterator $iterator, int $flags = RecursiveCachingIterator::CALL_TOSTRING)\nConstruct',
	'RecursiveCallbackFilterIterator': '(RecursiveIterator $iterator, callable $callback)\nCreate a RecursiveCallbackFilterIterator from a RecursiveIterator',
	'RecursiveDirectoryIterator': '(string $directory, int $flags = FilesystemIterator::KEY_AS_PATHNAME | FilesystemIterator::CURRENT_AS_FILEINFO)\nConstructs a RecursiveDirectoryIterator',
	'RecursiveFilterIterator': '(RecursiveIterator $iterator)\nCreate a RecursiveFilterIterator from a RecursiveIterator',
	'RecursiveIteratorIterator': '(Traversable $iterator, int $mode = RecursiveIteratorIterator::LEAVES_ONLY, int $flags = ?)\nConstruct a RecursiveIteratorIterator',
	'RecursiveRegexIterator': '(RecursiveIterator $iterator, string $pattern, int $mode = RecursiveRegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreates a new RecursiveRegexIterator',
	'RecursiveTreeIterator': '(RecursiveIterator|IteratorAggregate $iterator, int $flags = RecursiveTreeIterator::BYPASS_KEY, int $cachingIteratorFlags = CachingIterator::CATCH_GET_CHILD, int $mode = RecursiveTreeIterator::SELF_FIRST)\nConstruct a RecursiveTreeIterator',
	'RegexIterator': '(Iterator $iterator, string $pattern, int $mode = RegexIterator::MATCH, int $flags = ?, int $pregFlags = ?)\nCreate a new RegexIterator',
	'SplFileInfo': '(string $filename)\nConstruct a new SplFileInfo object',
	'SplFileObject': '(string $filename, string $mode = "r", bool $useIncludePath = false, resource|null $context = null)\nConstruct a new file object',
	'SplFixedArray': '(int $size = ?)\nConstructs a new fixed array',
	'SplTempFileObject': '(int $maxMemory = 2 * 1024 * 1024)\nConstruct a new temporary file object',
	'BadFunctionCallException': 'Exception thrown if a callback refers to an undefined function or if some arguments are missing',
	'BadMethodCallException': 'Exception thrown if a callback refers to an undefined method or if some arguments are missing',
	'DomainException': 'Exception thrown if a value does not adhere to a defined valid data domain',
	'EmptyIterator': 'The EmptyIterator class for an empty iterator',
	'InvalidArgumentException': 'Exception thrown if an argument is not of the expected type',
	'LengthException': 'Exception thrown if a length is invalid',
	'LogicException': 'Exception that represents error in the program logic',
	'OuterIterator': 'Classes implementing OuterIterator can be used to iterate over iterators',
	'OutOfBoundsException': 'Exception thrown if a value is not a valid key',
	'OutOfRangeException': 'Exception thrown when an illegal index was requested',
	'OverflowException': 'Exception thrown when adding an element to a full container',
	'RangeException': 'Exception thrown to indicate range errors during program execution',
	'RecursiveArrayIterator': 'This iterator allows for unsetting and modifying values and keys while iterating over arrays and objects, in the same way as the ArrayIterator',
	'RecursiveIterator': 'Classes implementing RecursiveIterator can be used to iterate over iterators recursively',
	'RuntimeException': 'Exception thrown if an error which can only be found on runtime occurs',
	'SeekableIterator': 'The Seekable iterator',
	'SplDoublyLinkedList': 'The SplDoublyLinkedList class provides the main functionalities of a doubly linked list',
	'SplHeap': 'The SplHeap class provides the main functionalities of a Heap',
	'SplMaxHeap': 'The SplMaxHeap class provides the main functionalities of a heap, keeping the maximum on the top',
	'SplMinHeap': 'The SplMinHeap class provides the main functionalities of a heap, keeping the minimum on the top',
	'SplObjectStorage': 'The SplObjectStorage class provides a map from objects to data or, by ignoring data, an object set',
	'SplObserver': 'The SplObserver interface is used alongside SplSubject to implement the Observer Design Pattern',
	'SplPriorityQueue': 'The SplPriorityQueue class provides the main functionalities of a prioritized queue, implemented using a max heap',
	'SplQueue': 'The SplQueue class provides the main functionalities of a queue implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_FIFO',
	'SplStack': 'The SplStack class provides the main functionalities of a stack implemented using a doubly linked list by setting the iterator mode to SplDoublyLinkedList::IT_MODE_LIFO',
	'SplSubject': 'The SplSubject interface is used alongside SplObserver to implement the Observer Design Pattern',
	'UnderflowException': 'Exception thrown when performing an invalid operation on an empty container, such as removing an element',
	'UnexpectedValueException': 'Exception thrown if a value does not match with a set of values',
	'streamWrapper': 'Constructs a new stream wrapper',
	'php_user_filter': 'Children of this class are passed to stream_filter_register',
	'StreamBucket': 'A stream bucket is a chunk of a stream which can be extracted from bucket brigades',
	'BcMath\number': '(string|int $num)\nCreates a BcMath\number object',
	'com': '(string $module_name, array|string|null $server_name = null, int $codepage = CP_ACP, string $typelib = "")\ncom class constructor',
	'COMPersistHelper': '(variant|null $variant = null)\nConstruct a COMPersistHelper object',
	'dotnet': '(string $assembly_name, string $datatype_name, int $codepage = CP_ACP)\ndotnet class constructor',
	'variant': '(mixed $value = null, int $type = VT_EMPTY, int $codepage = CP_ACP)\nvariant class constructor',
	'com_safearray_proxy': 'com_safearray_proxy is an internal class used for resolving multi-dimensional array accesses on SafeArray types',
	'Dba\\Connection': 'A fully opaque class which replaces a dba resource as of PHP 8',
	'FFI': '(FFI\\CType|string $type, bool $owned = true, bool $persistent = false): FFI\\CData|null\nCreates a C data structure',
	'FFI\\CData': 'FFI\\CData objects can be used in a number of ways as a regular PHP data: C data of scalar types can be read and assigned via the $cdata property, e',
	'FFI': 'Objects of this class are created by the factory methods FFI::cdef, FFI::load or FFI::scope',
	'finfo': '(int $flags = FILEINFO_NONE, string|null $magic_database = null)\nAlias finfo_open',
	'FTP\\Connection': 'A fully opaque class which replaces a ftp resource as of PHP 8',
	'GdFont': 'A fully opaque class which replaces gd font resources as of PHP 8',
	'GdImage': 'A fully opaque class which replaces gd resources as of PHP 8',
	'Collator': '(string $locale)\nCreate a collator',
	'IntlBreakIterator': 'Private constructor for disallowing instantiation',
	'IntlCalendar': 'Private constructor for disallowing instantiation',
	'IntlGregorianCalendar': '(IntlTimeZone $tz = ?, string $locale = ?)\nCreate the Gregorian Calendar class',
	'IntlGregorianCalendar': '(int $timeZoneOrYear, int $localeOrMonth, int $dayOfMonth)\nCreate the Gregorian Calendar class',
	'IntlGregorianCalendar': '(int $timeZoneOrYear, int $localeOrMonth, int $dayOfMonth, int $hour, int $minute, int $second = ?)\nCreate the Gregorian Calendar class',
	'IntlRuleBasedBreakIterator': '(string $rules, bool $compiled = false)\nCreate iterator from ruleset',
	'IntlTimeZone': 'Private constructor to disallow direct instantiation',
	'Spoofchecker': 'Constructor',
	'Transliterator': 'Private constructor to deny instantiation',
	'UConverter': '(string|null $destination_encoding = null, string|null $source_encoding = null)\nCreate UConverter object',
	'IntlDateFormatter': 'Date Formatter is a concrete class that enables locale-dependent formatting/parsing of dates using pattern strings and/or canned patterns',
	'IntlChar': 'IntlChar provides access to a number of utility methods that can be used to access information about Unicode characters',
	'IntlCodePointBreakIterator': 'This break iterator identifies the boundaries between UTF-8 code points',
	'IntlDatePatternGenerator': 'Generates localized date and/or time format pattern strings suitable for use in IntlDateFormatter',
	'IntlException': 'This class is used for generating exceptions when errors occur inside intl functions',
	'IntlIterator': 'This class represents iterator objects throughout the intl extension whenever the iterator cannot be identified with any other object provided by the extension',
	'IntlPartsIterator': 'Objects of this class can be obtained from IntlBreakIterator objects',
	'Locale': 'Examples of identifiers include: en-US (English, United States) zh-Hant-TW (Chinese, Traditional Script, Taiwan) fr-CA, fr-FR (French for Canada and France respectively)',
	'MessageFormatter': 'MessageFormatter is a concrete class that enables users to produce concatenated, language-neutral messages',
	'Normalizer': 'The Unicode Consortium has defined a number of normalization forms reflecting the various needs of applications: Normalization Form D (NFD) - Canonical Decomposition Normalization Form C (NFC) - Canonical Decomposition followed by Canonical Composition Normalization Form KD (NFKD) - Compatibility Decomposition Normalization Form KC (NFKC) - Compatibility Decomposition followed by Canonical Composition The different forms are defined in terms of a set of transformations on the text, transformations that are expressed by both an algorithm and a set of data files',
	'NumberFormatter': 'For currencies you can use currency format type to create a formatter that returns a string with the formatted number and the appropriate currency sign',
	'ResourceBundle': 'Localized software products often require sets of data that are to be customized depending on current locale, e',
	'PDO': '(string $dsn, string|null $username = null, string|null $password = null, array|null $options = null)\nCreates a PDO instance representing a connection to a database',
	'PDOException': 'Represents an error raised by PDO',
	'PDORow': 'Represents a row from a result set returned by PDOStatement::fetch called with PDO_FETCH_LAZY fetch mode',
	'PDOStatement': 'Represents a prepared statement and, after the statement is executed, an associated result set',
	'Phar': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, string|null $alias = null)\nConstruct a Phar archive object',
	'PharData': '(string $filename, int $flags = FilesystemIterator::SKIP_DOTS | FilesystemIterator::UNIX_PATHS, string|null $alias = null, int $format = ?)\nConstruct a non-executable tar or zip archive object',
	'PharFileInfo': '(string $filename)\nConstruct a Phar entry object',
	'PharException': 'The PharException class provides a phar-specific exception class for try/catch blocks',
	'SysvMessageQueue': 'A fully opaque class which replaces a sysvmsg queue resource as of PHP 8',
	'SysvSemaphore': 'A fully opaque class which replaces a sysvsem resource as of PHP 8',
	'SysvSharedMemory': 'A fully opaque class which replaces a sysvshm resource as of PHP 8',
	'SessionHandler': 'SessionHandler is a special class that can be used to expose the current internal PHP session save handler by inheritance',
	'SessionHandlerInterface': 'SessionHandlerInterface is an interface which defines the minimal prototype for creating a custom session handler',
	'SessionIdInterface': 'SessionIdInterface is an interface which defines optional methods for creating a custom session handler',
	'SessionUpdateTimestampHandlerInterface': 'SessionUpdateTimestampHandlerInterface is an interface which defines optional methods for creating a custom session handler',
	'Shmop': 'A fully opaque class which replaces shmop resources as of PHP 8',
	'AddressInfo': 'A fully opaque class which replaces AddressInfo resources as of PHP 8',
	'Socket': 'A fully opaque class which replaces Socket resources as of PHP 8',
	'SQLite3': '(string $filename, int $flags = SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE, string $encryptionKey = "")\nInstantiates an SQLite3 object and opens an SQLite 3 database',
	'SQLite3Result': 'Constructs an SQLite3Result',
	'SQLite3Stmt': '(SQLite3 $sqlite3, string $query)\nConstructs an SQLite3Stmt object',
	'SQLite3Exception': 'Represents a SQLite3 specific exception',
	'PhpToken': '(int $id, string $text, int $line = -1, int $pos = -1)\nReturns a new PhpToken object',
	'DeflateContext': 'A fully opaque class which replaces zlib',
	'InflateContext': 'A fully opaque class which replaces zlib',
	'CURLStringFile': '(string $data, string $postname, string $mime = "application/octet-stream")\nCreate a CURLStringFile object',
	'CURLFile': 'This class or CURLStringFile should be used to upload a file with CURLOPT_POSTFIELDS',
	'CurlHandle': 'A fully opaque class which replaces curl resources as of PHP 8',
	'CurlMultiHandle': 'A fully opaque class which replaces curl_multi resources as of PHP 8',
	'CurlShareHandle': 'A fully opaque class which replaces curl_share resources as of PHP 8',
	'CurlSharePersistentHandle': 'Represents a persistent cURL "share" handle',
	'DOMAttr': '(string $name, string $value = "")\nCreates a new DOMAttr object',
	'DOMCdataSection': '(string $data)\nConstructs a new DOMCdataSection object',
	'DOMComment': '(string $data = "")\nCreates a new DOMComment object',
	'DOMDocument': '(string $version = "1.0", string $encoding = "")\nCreates a new DOMDocument object',
	'DOMDocumentFragment': 'Constructs a DOMDocumentFragment object',
	'DOMElement': '(string $qualifiedName, string|null $value = null, string $namespace = "")\nCreates a new DOMElement object',
	'DOMEntityReference': '(string $name)\nCreates a new DOMEntityReference object',
	'DOMImplementation': 'Creates a new DOMImplementation object',
	'DOMProcessingInstruction': '(string $name, string $value = "")\nCreates a new DOMProcessingInstruction object',
	'DOMText': '(string $data = "")\nCreates a new DOMText object',
	'DOMXPath': '(DOMDocument $document, bool $registerNodeNS = true)\nCreates a new DOMXPath object',
	'DOMCharacterData': 'Represents nodes with character data',
	'DOMDocumentType': 'Each DOMDocument has a doctype attribute whose value is either null or a DOMDocumentType object',
	'DOMEntity': 'This interface represents a known entity, either parsed or unparsed, in an XML document',
	'DOMException': 'See also ',
	'DOMNodeList': 'Represents a live list of nodes',
	'Dom\\Attr': 'Dom\\Attr represents an attribute in the Dom\\Element object',
	'Dom\\CDATASection': 'The Dom\\CDATASection class inherits from Dom\\Text for textual representation of CData constructs',
	'Dom\\CharacterData': 'This is the modern, spec-compliant equivalent of DOMCharacterData',
	'Dom\\ChildNode': 'This is the modern, spec-compliant equivalent of DOMChildNode',
	'Dom\\Comment': 'This is the modern, spec-compliant equivalent of DOMComment',
	'Dom\\Document': 'This is the modern, spec-compliant equivalent of DOMDocument',
	'Dom\\DocumentFragment': 'This represents a document fragment, which can be used as a container for other nodes',
	'Dom\\DocumentType': 'Each Dom\\Document has a doctype attribute whose value is either null or a Dom\\DocumentType object',
	'Dom\\DtdNamedNodeMap': 'Represents a named node map for entities and notation nodes of the DTD',
	'Dom\\Element': 'Represents an element',
	'Dom\\Entity': 'This is the modern, spec-compliant equivalent of DOMEntity',
	'Dom\\EntityReference': 'This is the modern, spec-compliant equivalent of DOMEntityReference',
	'Dom\\HTMLCollection': 'Represents a static set of elements',
	'Dom\\HTMLDocument': 'Represents an HTML document',
	'Dom\\HTMLElement': 'Represents an element in the HTML namespace',
	'Dom\namedNodeMap': 'Represents the set of attributes on an element',
	'Dom\namespaceInfo': 'This represents immutable information about namespaces of an element',
	'Dom\node': 'This is the modern, spec-compliant equivalent of DOMNode',
	'Dom\nodeList': 'This is the modern, spec-compliant equivalent of DOMNodeList',
	'Dom\\ParentNode': 'This is the modern, spec-compliant equivalent of DOMParentNode',
	'Dom\\ProcessingInstruction': 'This is the modern, spec-compliant equivalent of DOMProcessingInstruction',
	'Dom\\Text': 'The Dom\\Text class inherits from Dom\\CharacterData and represents a text node',
	'Dom\\TokenList': 'Represents a set of tokens in an attribute (e',
	'Dom\\XMLDocument': 'Represents an XML document',
	'Dom\\XPath': 'This is the modern, spec-compliant equivalent of DOMXPath',
	'EnchantBroker': 'A fully opaque class which replaces enchant_broker resources as of PHP 8',
	'EnchantDictionary': 'A fully opaque class which replaces enchant_dict resources as of PHP 8',
	'GMP': '(int|string $num = ?, int $base = ?)\nCreate GMP number',
	'LDAP\\Connection': 'A fully opaque class which replaces a ldap resource as of PHP 8',
	'LDAP\\Result': 'A fully opaque class which replaces a ldap result resource as of PHP 8',
	'LDAP\\ResultEntry': 'A fully opaque class which replaces a ldap result entry resource as of PHP 8',
	'LibXMLError': 'Contains various information about errors thrown by libxml',
	'mysqli_result': '(mysqli $mysql, int $result_mode = MYSQLI_STORE_RESULT)\nConstructs a mysqli_result object',
	'mysqli_stmt': '(mysqli $mysql, string|null $query = null)\nConstructs a new mysqli_stmt object',
	'mysqli_warning': 'Private constructor to disallow direct instantiation',
	'mysqli': 'Represents a connection between PHP and a MySQL database',
	'mysqli_driver': 'The mysqli_driver class is an instance of the monostate pattern, i',
	'mysqli_sql_exception': 'The mysqli exception handling class',
	'OpenSSLAsymmetricKey': 'A fully opaque class which replaces OpenSSL key resources as of PHP 8',
	'OpenSSLCertificate': 'A fully opaque class which replaces OpenSSL X',
	'OpenSSLCertificateSigningRequest': 'A fully opaque class which replaces OpenSSL X',
	'Pdo\\Dblib': 'A PDO subclass representing a connection using the DBLib PDO driver',
	'Pdo\\Firebird': 'A PDO subclass representing a connection using the Firebird PDO driver',
	'Pdo\\Mysql': 'This driver supports a dedicated SQL query parser for the MySQL dialect',
	'Pdo\\Odbc': 'A PDO subclass representing a connection using the ODBC PDO driver',
	'Pdo\\Pgsql': 'This driver supports a dedicated SQL query parser for the PostgreSQL dialect',
	'Pdo\\Sqlite': 'This driver supports a dedicated SQL query parser for the SQLite dialect',
	'PgSql\\Connection': 'A fully opaque class which replaces a pgsql link resource as of PHP 8',
	'PgSql\\Lob': 'A fully opaque class which replaces a pgsql large object resource as of PHP 8',
	'PgSql\\Result': 'A fully opaque class which replaces a pgsql result resource as of PHP 8',
	'SimpleXMLElement': '(string $data, int $options = ?, bool $dataIsURL = false, string $namespaceOrPrefix = "", bool $isPrefix = false)\nCreates a new SimpleXMLElement object',
	'SimpleXMLIterator': 'The SimpleXMLIterator provides recursive iteration over all nodes of a SimpleXMLElement object',
	'SNMP': '(int $version, string $hostname, string $community, int $timeout = -1, int $retries = -1)\nCreates SNMP instance representing session to remote SNMP agent',
	'SNMPException': 'Represents an error raised by SNMP',
	'SoapClient': '(string|null $wsdl, array $options = [])\nSoapClient constructor',
	'SoapFault': '(array|string|null $code, string $string, string|null $actor = null, mixed $details = null, string|null $name = null, mixed $headerFault = null)\nSoapFault constructor',
	'SoapHeader': '(string $namespace, string $name, mixed $data = ?, bool $mustunderstand = ?, string $actor = ?)\nSoapHeader constructor',
	'SoapParam': '(mixed $data, string $name)\nSoapParam constructor',
	'SoapServer': '(string|null $wsdl, array $options = [])\nSoapServer constructor',
	'SoapVar': '(mixed $data, int|null $encoding, string|null $typeName = null, string|null $typeNamespace = null, string|null $nodeName = null, string|null $nodeNamespace = null)\nSoapVar constructor',
	'SodiumException': 'Exceptions thrown by the sodium functions',
	'tidy': '(string|null $filename = null, array|string|null $config = null, string|null $encoding = null, bool $useIncludePath = false)\nConstructs a new tidy object',
	'tidyNode': 'Private constructor to disallow direct instantiation',
	'XMLParser': 'A fully opaque class which replaces xml resources as of PHP 8',
	'XMLReader': 'The XMLReader extension is an XML Pull parser',
	'XSLTProcessor': 'Creates a new XSLTProcessor object',
	'ZipArchive': 'A file archive, compressed with Zip',
});
