From 256c8b633e1154a19281007215f8eecbd0880d82 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Fri, 25 Sep 2020 12:29:21 +0200
Subject: [PATCH 01/10] Update ext/standard parameter names

---
 ext/standard/basic_functions.stub.php  | 471 +++++++++++++------------
 ext/standard/basic_functions_arginfo.h | 433 +++++++++++------------
 2 files changed, 448 insertions(+), 456 deletions(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index b640fce9eead6..18deafa13df7f 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -12,8 +12,8 @@ function header_register_callback(callable $callback): bool {}
 
 /* main/output.c */
 
-/** @param callable $user_function */
-function ob_start($user_function = null, int $chunk_size = 0, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool {}
+/** @param callable $callback */
+function ob_start($callback = null, int $chunk_size = 0, int $flags = PHP_OUTPUT_HANDLER_STDFLAGS): bool {}
 
 function ob_flush(): bool {}
 
@@ -37,7 +37,7 @@ function ob_list_handlers(): array {}
 
 function ob_get_status(bool $full_status = false): array {}
 
-function ob_implicit_flush(bool $flag = true): void {}
+function ob_implicit_flush(bool $enable = true): void {}
 
 function output_reset_rewrite_vars(): bool {}
 
@@ -45,10 +45,10 @@ function output_add_rewrite_var(string $name, string $value): bool {}
 
 /* main/streams/userspace.c */
 
-function stream_wrapper_register(string $protocol, string $classname, int $flags = 0): bool {}
+function stream_wrapper_register(string $protocol, string $class, int $flags = 0): bool {}
 
 /** @alias stream_wrapper_register */
-function stream_register_wrapper(string $protocol, string $classname, int $flags = 0): bool {}
+function stream_register_wrapper(string $protocol, string $class, int $flags = 0): bool {}
 
 function stream_wrapper_unregister(string $protocol): bool {}
 
@@ -62,10 +62,10 @@ function krsort(array &$array, int $flags = SORT_REGULAR): bool {}
 
 function ksort(array &$array, int $flags = SORT_REGULAR): bool {}
 
-function count(Countable|array $var, int $mode = COUNT_NORMAL): int {}
+function count(Countable|array $value, int $mode = COUNT_NORMAL): int {}
 
 /** @alias count */
-function sizeof(Countable|array $var, int $mode = COUNT_NORMAL): int {}
+function sizeof(Countable|array $value, int $mode = COUNT_NORMAL): int {}
 
 function natsort(array &$array): bool {}
 
@@ -85,20 +85,20 @@ function uasort(array &$array, callable $callback): bool {}
 
 function uksort(array &$array, callable $callback): bool {}
 
-function end(array|object &$arg): mixed {}
+function end(array|object &$array): mixed {}
 
-function prev(array|object &$arg): mixed {}
+function prev(array|object &$array): mixed {}
 
-function next(array|object &$arg): mixed {}
+function next(array|object &$array): mixed {}
 
-function reset(array|object &$arg): mixed {}
+function reset(array|object &$array): mixed {}
 
-function current(array|object $arg): mixed {}
+function current(array|object $array): mixed {}
 
 /** @alias current */
-function pos(array|object $arg): mixed {}
+function pos(array|object $array): mixed {}
 
-function key(array|object $arg): int|string|null {}
+function key(array|object $array): int|string|null {}
 
 function min(mixed $arg, mixed ...$args): mixed {}
 
@@ -113,7 +113,7 @@ function in_array(mixed $needle, array $haystack, bool $strict = false): bool {}
 function array_search(mixed $needle, array $haystack, bool $strict = false): int|string|false {}
 
 /** @prefer-ref $array */
-function extract(array &$array, int $extract_type = EXTR_OVERWRITE, string $prefix = ""): int {}
+function extract(array &$array, int $flags = EXTR_OVERWRITE, string $prefix = ""): int {}
 
 /**
  * @param array|string $var_name
@@ -121,25 +121,25 @@ function extract(array &$array, int $extract_type = EXTR_OVERWRITE, string $pref
  */
 function compact($var_name, ...$var_names): array {}
 
-function array_fill(int $start_key, int $count, mixed $value): array {}
+function array_fill(int $start, int $length, mixed $value): array {}
 
 function array_fill_keys(array $keys, mixed $value): array {}
 
 /**
- * @param string|int|float $low
- * @param string|int|float $high
+ * @param string|int|float $start
+ * @param string|int|float $end
  */
-function range($low, $high, int|float $step = 1): array {}
+function range($start, $end, int|float $step = 1): array {}
 
 function shuffle(array &$array): bool {}
 
-function array_pop(array &$stack): mixed {}
+function array_pop(array &$array): mixed {}
 
-function array_shift(array &$stack): mixed {}
+function array_shift(array &$array): mixed {}
 
-function array_unshift(array &$stack, mixed ...$values): int {}
+function array_unshift(array &$array, mixed ...$values): int {}
 
-function array_splice(array &$array, int $offset, ?int $length = null, mixed $replacements = []): array {}
+function array_splice(array &$array, int $offset, ?int $length = null, mixed $replacement = []): array {}
 
 function array_slice(array $array, int $offset, ?int $length = null, bool $preserve_keys = false): array {}
 
@@ -165,7 +165,7 @@ function array_column(array $array, int|string|null $column_key, int|string|null
 
 function array_reverse(array $array, bool $preserve_keys = false): array {}
 
-function array_pad(array $array, int $pad_size, mixed $pad_value): array {}
+function array_pad(array $array, int $length, mixed $value): array {}
 
 function array_flip(array $array): array {}
 
@@ -216,14 +216,14 @@ function array_udiff_assoc(array $array, ...$rest): array {}
 function array_udiff_uassoc(array $array, ...$rest): array {}
 
 /**
- * @param array $array1
+ * @param array $array
  * @param array|int $rest
- * @prefer-ref $array1
+ * @prefer-ref $array
  * @prefer-ref $rest
  */
-function array_multisort(&$array1, &...$rest): bool {}
+function array_multisort(&$array, &...$rest): bool {}
 
-function array_rand(array $array, int $num_req = 1): int|string|array {}
+function array_rand(array $array, int $num = 1): int|string|array {}
 
 function array_sum(array $array): int|float {}
 
@@ -244,15 +244,15 @@ function array_key_exists($key, array $array): bool {}
  */
 function key_exists($key, array $array): bool {}
 
-function array_chunk(array $array, int $size, bool $preserve_keys = false): array {}
+function array_chunk(array $array, int $length, bool $preserve_keys = false): array {}
 
 function array_combine(array $keys, array $values): array {}
 
 /* base64.c */
 
-function base64_encode(string $str): string {}
+function base64_encode(string $string): string {}
 
-function base64_decode(string $str, bool $strict = false): string|false {}
+function base64_decode(string $string, bool $strict = false): string|false {}
 
 /* basic_functions.c */
 
@@ -260,16 +260,16 @@ function constant(string $name): mixed {}
 
 function ip2long(string $ip_address): int|false {}
 
-function long2ip(int $proper_address): string|false {}
+function long2ip(int $ip_address): string|false {}
 
-function getenv(?string $variable = null, bool $local_only = false): string|array|false {}
+function getenv(?string $name = null, bool $local_only = false): string|array|false {}
 
 #ifdef HAVE_PUTENV
 function putenv(string $setting): bool {}
 #endif
 
-/** @param int $optind */
-function getopt(string $options, array $longopts = [], &$optind = null): array|false {}
+/** @param int $rest_index */
+function getopt(string $options, array $long_options = [], &$rest_index = null): array|false {}
 
 function flush(): void {}
 
@@ -285,7 +285,7 @@ function time_sleep_until(float $timestamp): bool {}
 
 function get_current_user(): string {}
 
-function get_cfg_var(string $option_name): string|array|false {}
+function get_cfg_var(string $name): string|array|false {}
 
 function error_log(string $message, int $message_type = 0, ?string $destination = null, ?string $extra_headers = null): bool {}
 
@@ -293,15 +293,15 @@ function error_get_last(): ?array {}
 
 function error_clear_last(): void {}
 
-function call_user_func(callable $function, mixed ...$args): mixed {}
+function call_user_func(callable $callback, mixed ...$args): mixed {}
 
-function call_user_func_array(callable $function, array $args): mixed {}
+function call_user_func_array(callable $callback, array $args): mixed {}
 
-function forward_static_call(callable $function, mixed ...$args): mixed {}
+function forward_static_call(callable $callback, mixed ...$args): mixed {}
 
-function forward_static_call_array(callable $function, array $args): mixed {}
+function forward_static_call_array(callable $callback, array $args): mixed {}
 
-function register_shutdown_function(callable $function, mixed ...$args): ?bool {}
+function register_shutdown_function(callable $callback, mixed ...$args): ?bool {}
 
 function highlight_file(string $filename, bool $return = false): string|bool {}
 
@@ -312,28 +312,28 @@ function php_strip_whitespace(string $filename): string {}
 
 function highlight_string(string $string, bool $return = false): string|bool {}
 
-function ini_get(string $varname): string|false {}
+function ini_get(string $name): string|false {}
 
 function ini_get_all(?string $extension = null, bool $details = true): array|false {}
 
-function ini_set(string $varname, string $value): string|false {}
+function ini_set(string $name, string $value): string|false {}
 
 /** @alias ini_set */
-function ini_alter(string $varname, string $value): string|false {}
+function ini_alter(string $name, string $value): string|false {}
 
-function ini_restore(string $varname): void {}
+function ini_restore(string $name): void {}
 
 function set_include_path(string $include_path): string|false {}
 
 function get_include_path(): string|false {}
 
-function print_r(mixed $var, bool $return = false): string|bool {}
+function print_r(mixed $value, bool $return = false): string|bool {}
 
 function connection_aborted(): int {}
 
 function connection_status(): int {}
 
-function ignore_user_abort(?bool $value = null): int {}
+function ignore_user_abort(?bool $enable = null): int {}
 
 #if HAVE_GETSERVBYNAME
 function getservbyname(string $service, string $protocol): int|false {}
@@ -344,16 +344,16 @@ function getservbyport(int $port, string $protocol): string|false {}
 #endif
 
 #if HAVE_GETPROTOBYNAME
-function getprotobyname(string $name): int|false {}
+function getprotobyname(string $protocol): int|false {}
 #endif
 
 #if HAVE_GETPROTOBYNUMBER
 function getprotobynumber(int $protocol): string|false {}
 #endif
 
-function register_tick_function(callable $function, mixed ...$args): bool {}
+function register_tick_function(callable $callback, mixed ...$args): bool {}
 
-function unregister_tick_function(callable $function): void {}
+function unregister_tick_function(callable $callback): void {}
 
 function is_uploaded_file(string $path): bool {}
 
@@ -373,15 +373,15 @@ function sys_getloadavg(): array|false {}
 
 /* browscap.c */
 
-function get_browser(?string $browser_name = null, bool $return_array = false): object|array|false {}
+function get_browser(?string $user_agent = null, bool $return_array = false): object|array|false {}
 
 /* crc32.c */
 
-function crc32(string $str): int {}
+function crc32(string $string): int {}
 
 /* crypt.c */
 
-function crypt(string $str, string $salt): string {}
+function crypt(string $string, string $salt): string {}
 
 /* datetime.c */
 
@@ -408,23 +408,23 @@ function dns_check_record(string $hostname, string $type = "MX"): bool {}
 function checkdnsrr(string $hostname, string $type = "MX"): bool {}
 
 /**
- * @param array $authns
- * @param array $addtl
+ * @param array $authoritative_name_servers
+ * @param array $additional_records
  */
-function dns_get_record(string $hostname, int $type = DNS_ANY, &$authns = null, &$addtl = null, bool $raw = false): array|false {}
+function dns_get_record(string $hostname, int $type = DNS_ANY, &$authoritative_name_servers = null, &$additional_records = null, bool $raw = false): array|false {}
 
 /**
- * @param array $mxhosts
- * @param array $weight
+ * @param array $hosts
+ * @param array $weights
  */
-function dns_get_mx(string $hostname, &$mxhosts, &$weight = null): bool {}
+function dns_get_mx(string $hostname, &$hosts, &$weights = null): bool {}
 
 /**
- * @param array $mxhosts
- * @param array $weight
+ * @param array $hosts
+ * @param array $weights
  * @alias dns_get_mx
  */
-function getmxrr(string $hostname, &$mxhosts, &$weight = null): bool {}
+function getmxrr(string $hostname, &$hosts, &$weights = null): bool {}
 #endif
 
 /* net.c */
@@ -434,12 +434,12 @@ function net_get_interfaces(): array|false {}
 /* ftok.c */
 
 #if HAVE_FTOK
-function ftok(string $pathname, string $proj): int {}
+function ftok(string $filename, string $project_id): int {}
 #endif
 
 /* hrtime.c */
 
-function hrtime(bool $get_as_number = false): array|int|float|false {}
+function hrtime(bool $as_number = false): array|int|float|false {}
 
 /* lcg.c */
 
@@ -447,9 +447,9 @@ function lcg_value(): float {}
 
 /* md5.c */
 
-function md5(string $str, bool $raw_output = false): string {}
+function md5(string $string, bool $binary = false): string {}
 
-function md5_file(string $filename, bool $raw_output = false): string|false {}
+function md5_file(string $filename, bool $binary = false): string|false {}
 
 /* pageinfo.c */
 
@@ -465,14 +465,14 @@ function getlastmod(): int {}
 
 /* sha1.c */
 
-function sha1(string $str, bool $raw_output = false): string {}
+function sha1(string $string, bool $binary = false): string {}
 
-function sha1_file(string $filename, bool $raw_output = false): string|false {}
+function sha1_file(string $filename, bool $binary = false): string|false {}
 
 /* syslog.c */
 
 #ifdef HAVE_SYSLOG_H
-function openlog(string $ident, int $option, int $facility): bool {}
+function openlog(string $prefix, int $flags, int $facility): bool {}
 
 function closelog(): bool {}
 
@@ -480,7 +480,7 @@ function syslog(int $priority, string $message): bool {}
 #endif
 
 #ifdef HAVE_INET_NTOP
-function inet_ntop(string $in_addr): string|false {}
+function inet_ntop(string $ip_address): string|false {}
 #endif
 
 #ifdef HAVE_INET_PTON
@@ -489,10 +489,10 @@ function inet_pton(string $ip_address): string|false {}
 
 /* metaphone.c */
 
-function metaphone(string $text, int $phonemes = 0): string {}
+function metaphone(string $string, int $max_phonemes = 0): string {}
 
 /* {{{ head.c */
-function header(string $string, bool $replace = true, int $http_response_code = 0): void {}
+function header(string $header, bool $replace = true, int $http_response_code = 0): void {}
 
 function header_remove(?string $name = null): void {}
 
@@ -512,15 +512,15 @@ function headers_list(): array {}
 
 /* {{{ html.c */
 
-function htmlspecialchars(string $string, int $quote_style = ENT_COMPAT, ?string $encoding = null, bool $double_encode = true): string {}
+function htmlspecialchars(string $string, int $flags = ENT_COMPAT, ?string $encoding = null, bool $double_encode = true): string {}
 
-function htmlspecialchars_decode(string $string, int $quote_style = ENT_COMPAT): string {}
+function htmlspecialchars_decode(string $string, int $flags = ENT_COMPAT): string {}
 
-function html_entity_decode(string $string, int $quote_style = ENT_COMPAT, ?string $encoding = null): string {}
+function html_entity_decode(string $string, int $flags = ENT_COMPAT, ?string $encoding = null): string {}
 
-function htmlentities(string $string, int $quote_style = ENT_COMPAT, ?string $encoding = null, bool $double_encode = true): string {}
+function htmlentities(string $string, int $flags = ENT_COMPAT, ?string $encoding = null, bool $double_encode = true): string {}
 
-function get_html_translation_table(int $table = HTML_SPECIALCHARS, int $quote_style = ENT_COMPAT, string $encoding = "UTF-8"): array {}
+function get_html_translation_table(int $table = HTML_SPECIALCHARS, int $flags = ENT_COMPAT, string $encoding = "UTF-8"): array {}
 
 /* }}} */
 
@@ -529,53 +529,53 @@ function get_html_translation_table(int $table = HTML_SPECIALCHARS, int $quote_s
 function assert(mixed $assertion, Throwable|string|null $description = null): bool {}
 
 /** @param string|callable|null $value */
-function assert_options(int $what, $value = UNKNOWN): array|object|int|string|null {}
+function assert_options(int $option, $value = UNKNOWN): array|object|int|string|null {}
 
 /* string.c */
 
-function bin2hex(string $data): string {}
+function bin2hex(string $string): string {}
 
-function hex2bin(string $data): string|false {}
+function hex2bin(string $string): string|false {}
 
-function strspn(string $str, string $mask, int $start = 0, ?int $len = null): int {}
+function strspn(string $string, string $characters, int $start = 0, ?int $length = null): int {}
 
-function strcspn(string $str, string $mask, int $start = 0, ?int $len = null): int {}
+function strcspn(string $string, string $characters, int $start = 0, ?int $length = null): int {}
 
 #if HAVE_NL_LANGINFO
 function nl_langinfo(int $item): string|false {}
 #endif
 
-function strcoll(string $str1, string $str2): int {}
+function strcoll(string $string1, string $string2): int {}
 
-function trim(string $str, string $character_mask = " \n\r\t\v\0"): string {}
+function trim(string $string, string $characters = " \n\r\t\v\0"): string {}
 
-function rtrim(string $str, string $character_mask = " \n\r\t\v\0"): string {}
+function rtrim(string $string, string $characters = " \n\r\t\v\0"): string {}
 
 /** @alias rtrim */
-function chop(string $str, string $character_mask = " \n\r\t\v\0"): string {}
+function chop(string $string, string $characters = " \n\r\t\v\0"): string {}
 
-function ltrim(string $str, string $character_mask = " \n\r\t\v\0"): string {}
+function ltrim(string $string, string $characters = " \n\r\t\v\0"): string {}
 
-function wordwrap(string $str, int $width = 75, string $break = "\n", bool $cut = false): string {}
+function wordwrap(string $string, int $width = 75, string $break = "\n", bool $cut_long_words = false): string {}
 
-function explode(string $separator, string $str, int $limit = PHP_INT_MAX): array {}
+function explode(string $separator, string $string, int $limit = PHP_INT_MAX): array {}
 
-function implode(string|array $glue, ?array $pieces = null): string {}
+function implode(string|array $separator, ?array $array = null): string {}
 
 /** @alias implode */
-function join(string|array $glue, ?array $pieces = null): string {}
+function join(string|array $separator, ?array $array = null): string {}
 
-function strtok(string $str, ?string $token = null): string|false {}
+function strtok(string $string, ?string $token = null): string|false {}
 
-function strtoupper(string $str): string {}
+function strtoupper(string $string): string {}
 
-function strtolower(string $str): string {}
+function strtolower(string $string): string {}
 
 function basename(string $path, string $suffix = ""): string {}
 
 function dirname(string $path, int $levels = 1): string {}
 
-function pathinfo(string $path, int $options = PATHINFO_ALL): array|string {}
+function pathinfo(string $path, int $flags = PATHINFO_ALL): array|string {}
 
 function stristr(string $haystack, string $needle, bool $before_needle = false): string|false {}
 
@@ -600,50 +600,50 @@ function str_starts_with(string $haystack, string $needle): bool {}
 
 function str_ends_with(string $haystack, string $needle): bool {}
 
-function chunk_split(string $str, int $chunklen = 76, string $ending = "\r\n"): string {}
+function chunk_split(string $string, int $length = 76, string $separator = "\r\n"): string {}
 
-function substr(string $str, int $start, ?int $length = null): string {}
+function substr(string $string, int $start, ?int $length = null): string {}
 
-function substr_replace(array|string $str, array|string $replace, array|int $start, array|int|null $length = null): string|array {}
+function substr_replace(array|string $string, array|string $replace, array|int $start, array|int|null $length = null): string|array {}
 
-function quotemeta(string $str): string {}
+function quotemeta(string $string): string {}
 
 function ord(string $character): int {}
 
 function chr(int $codepoint): string {}
 
-function ucfirst(string $str): string {}
+function ucfirst(string $string): string {}
 
-function lcfirst(string $str): string {}
+function lcfirst(string $string): string {}
 
-function ucwords(string $str, string $delimiters = " \t\r\n\f\v"): string {}
+function ucwords(string $string, string $delimiters = " \t\r\n\f\v"): string {}
 
-function strtr(string $str, string|array $from, ?string $to = null): string {}
+function strtr(string $string, string|array $from, ?string $to = null): string {}
 
-function strrev(string $str): string {}
+function strrev(string $string): string {}
 
 /** @param float $percent */
-function similar_text(string $str1, string $str2, &$percent = null): int {}
+function similar_text(string $string1, string $string2, &$percent = null): int {}
 
-function addcslashes(string $str, string $charlist): string {}
+function addcslashes(string $string, string $characters): string {}
 
-function addslashes(string $str): string {}
+function addslashes(string $string): string {}
 
-function stripcslashes(string $str): string {}
+function stripcslashes(string $string): string {}
 
-function stripslashes(string $str): string {}
+function stripslashes(string $string): string {}
 
-/** @param int $replace_count */
-function str_replace(array|string $search, array|string $replace, string|array $subject, &$replace_count = null): string|array {}
+/** @param int $count */
+function str_replace(array|string $search, array|string $replace, string|array $subject, &$count = null): string|array {}
 
-/** @param int $replace_count */
-function str_ireplace(array|string $search, array|string $replace, string|array $subject, &$replace_count = null): string|array {}
+/** @param int $count */
+function str_ireplace(array|string $search, array|string $replace, string|array $subject, &$count = null): string|array {}
 
-function hebrev(string $str, int $max_chars_per_line = 0): string {}
+function hebrev(string $string, int $max_chars_per_line = 0): string {}
 
-function nl2br(string $str, bool $is_xhtml = true): string {}
+function nl2br(string $string, bool $use_xhtml = true): string {}
 
-function strip_tags(string $str, array|string|null $allowable_tags = null): string {}
+function strip_tags(string $string, array|string|null $allowed_tags = null): string {}
 
 /**
  * @param array|string $locales
@@ -656,37 +656,37 @@ function parse_str(string $string, &$result): void {}
 
 function str_getcsv(string $string, string $delimiter = ",", string $enclosure = "\"", string $escape = '\\'): array {}
 
-function str_repeat(string $input, int $mult): string {}
+function str_repeat(string $string, int $times): string {}
 
-function count_chars(string $input, int $mode = 0): array|string {}
+function count_chars(string $string, int $mode = 0): array|string {}
 
-function strnatcmp(string $s1, string $s2): int {}
+function strnatcmp(string $string1, string $string2): int {}
 
 function localeconv(): array {}
 
-function strnatcasecmp(string $s1, string $s2): int {}
+function strnatcasecmp(string $string1, string $string2): int {}
 
 function substr_count(string $haystack, string $needle, int $offset = 0, ?int $length = null): int {}
 
-function str_pad(string $input, int $pad_length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT): string {}
+function str_pad(string $string, int $length, string $pad_string = " ", int $pad_type = STR_PAD_RIGHT): string {}
 
-function sscanf(string $str, string $format, mixed &...$vars): array|int|null {}
+function sscanf(string $string, string $format, mixed &...$vars): array|int|null {}
 
-function str_rot13(string $str): string {}
+function str_rot13(string $string): string {}
 
-function str_shuffle(string $str): string {}
+function str_shuffle(string $string): string {}
 
-function str_word_count(string $str, int $format = 0, ?string $charlist = null): array|int {}
+function str_word_count(string $string, int $format = 0, ?string $characters = null): array|int {}
 
-function str_split(string $str, int $length = 1): array {}
+function str_split(string $string, int $length = 1): array {}
 
-function strpbrk(string $haystack, string $char_list): string|false {}
+function strpbrk(string $string, string $characters): string|false {}
 
-function substr_compare(string $main_str, string $str, int $offset, ?int $length = null, bool $case_insensitivity = false): int {}
+function substr_compare(string $main_string, string $string, int $offset, ?int $length = null, bool $case_insensitive = false): int {}
 
-function utf8_encode(string $data): string {}
+function utf8_encode(string $string): string {}
 
-function utf8_decode(string $data): string {}
+function utf8_decode(string $string): string {}
 
 /**
  * @param resource|null $context
@@ -754,10 +754,10 @@ function proc_nice(int $priority): bool {}
 /* file.c */
 
 /**
- * @param resource $handle
- * @param int $wouldblock
+ * @param resource $stream
+ * @param int $would_block
  */
-function flock($handle, int $operation, &$wouldblock = null): bool {}
+function flock($stream, int $operation, &$would_block = null): bool {}
 
 function get_meta_tags(string $filename, bool $use_include_path = false): array|false {}
 
@@ -770,28 +770,28 @@ function popen(string $command, string $mode) {}
 /** @param resource|null $context */
 function readfile(string $filename, bool $use_include_path = false, $context = null): int|false {}
 
-/** @param resource $handle */
-function rewind($handle): bool {}
+/** @param resource $stream */
+function rewind($stream): bool {}
 
 /** @param resource|null $context */
-function rmdir(string $dirname, $context = null): bool {}
+function rmdir(string $directory, $context = null): bool {}
 
 function umask(?int $mask = null): int {}
 
-/** @param resource $handle */
-function fclose($handle): bool {}
+/** @param resource $stream */
+function fclose($stream): bool {}
 
-/** @param resource $handle */
-function feof($handle): bool {}
+/** @param resource $stream */
+function feof($stream): bool {}
 
-/** @param resource $handle */
-function fgetc($handle): string|false {}
+/** @param resource $stream */
+function fgetc($stream): string|false {}
 
-/** @param resource $handle */
-function fgets($handle, ?int $length = null): string|false {}
+/** @param resource $stream */
+function fgets($stream, ?int $length = null): string|false {}
 
-/** @param resource $handle */
-function fread($handle, int $length): string|false {}
+/** @param resource $stream */
+function fread($stream, int $length): string|false {}
 
 /**
  * @param resource|null $context
@@ -800,45 +800,45 @@ function fread($handle, int $length): string|false {}
 function fopen(string $filename, string $mode, bool $use_include_path = false, $context = null) {}
 
 /** @param resource $stream */
-function fscanf($stream, string $format, mixed &...$args): array|int|false|null {}
+function fscanf($stream, string $format, mixed &...$vars): array|int|false|null {}
 
-/** @param resource $handle */
-function fpassthru($handle): int {}
+/** @param resource $stream */
+function fpassthru($stream): int {}
 
-/** @param resource $handle */
-function ftruncate($handle, int $size): bool {}
+/** @param resource $stream */
+function ftruncate($stream, int $size): bool {}
 
-/** @param resource $handle */
-function fstat($handle): array|false {}
+/** @param resource $stream */
+function fstat($stream): array|false {}
 
-/** @param resource $handle */
-function fseek($handle, int $offset, int $whence = SEEK_SET): int {}
+/** @param resource $stream */
+function fseek($stream, int $offset, int $whence = SEEK_SET): int {}
 
-/** @param resource $handle */
-function ftell($handle): int|false {}
+/** @param resource $stream */
+function ftell($stream): int|false {}
 
-/** @param resource $handle */
-function fflush($handle): bool {}
+/** @param resource $stream */
+function fflush($stream): bool {}
 
-/** @param resource $handle */
-function fwrite($handle, string $content, ?int $max_length = null): int|false {}
+/** @param resource $stream */
+function fwrite($stream, string $string, ?int $max_length = null): int|false {}
 
 /**
- * @param resource $handle
+ * @param resource $stream
  * @alias fwrite
  */
-function fputs($handle, string $content, ?int $max_length = null): int|false {}
+function fputs($stream, string $string, ?int $max_length = null): int|false {}
 
 /** @param resource|null $context */
-function mkdir(string $pathname, int $mode = 0777, bool $recursive = false, $context = null): bool {}
+function mkdir(string $directory, int $mode = 0777, bool $recursive = false, $context = null): bool {}
 
 /** @param resource|null $context */
-function rename(string $oldname, string $newname, $context = null): bool {}
+function rename(string $old_name, string $new_name, $context = null): bool {}
 
 /** @param resource|null $context */
 function copy(string $source, string $dest, $context = null): bool {}
 
-function tempnam(string $dir, string $prefix): string|false {}
+function tempnam(string $directory, string $prefix): string|false {}
 
 /** @return resource|false */
 function tmpfile() {}
@@ -847,7 +847,7 @@ function tmpfile() {}
 function file(string $filename, int $flags = 0, $context = null): array|false {}
 
 /** @param resource|null $context */
-function file_get_contents(string $filename, bool $use_include_path = false, $context = null, int $offset = 0, ?int $maxlen = null): string|false {}
+function file_get_contents(string $filename, bool $use_include_path = false, $context = null, int $offset = 0, ?int $max_length = null): string|false {}
 
 /** @param resource|null $context */
 function unlink(string $filename, $context = null): bool {}
@@ -855,11 +855,11 @@ function unlink(string $filename, $context = null): bool {}
 /** @param resource|null $context */
 function file_put_contents(string $filename, mixed $content, int $flags = 0, $context = null): int|false {}
 
-/** @param resource $handle */
-function fputcsv($handle, array $fields, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): int|false {}
+/** @param resource $stream */
+function fputcsv($stream, array $fields, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): int|false {}
 
-/** @param resource $handle */
-function fgetcsv($handle, ?int $length = null, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): array|false {}
+/** @param resource $stream */
+function fgetcsv($stream, ?int $length = null, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): array|false {}
 
 function realpath(string $path): string|false {}
 
@@ -923,7 +923,7 @@ function lchgrp(string $filename, string|int $group): bool {}
 function chmod(string $filename, int $mode): bool {}
 
 #if HAVE_UTIME
-function touch(string $filename, ?int $time = null, ?int $atime = null): bool {}
+function touch(string $filename, ?int $mtime = null, ?int $atime = null): bool {}
 #endif
 
 function clearstatcache(bool $clear_realpath_cache = false, string $filename = ""): void {}
@@ -941,39 +941,39 @@ function realpath_cache_size(): int {}
 
 /* formatted_print.c */
 
-function sprintf(string $format, mixed ...$args): string {}
+function sprintf(string $format, mixed ...$values): string {}
 
-function printf(string $format, mixed ...$args): int {}
+function printf(string $format, mixed ...$values): int {}
 
-function vprintf(string $format, array $args): int {}
+function vprintf(string $format, array $values): int {}
 
-function vsprintf(string $format, array $args): string {}
+function vsprintf(string $format, array $values): string {}
 
-/** @param resource $handle */
-function fprintf($handle, string $format, mixed ...$args): int {}
+/** @param resource $stream */
+function fprintf($stream, string $format, mixed ...$values): int {}
 
-/** @param resource $handle */
-function vfprintf($handle, string $format, array $args): int {}
+/** @param resource $stream */
+function vfprintf($stream, string $format, array $values): int {}
 
 /* fsock.c */
 
 /**
  * @param int $errno
- * @param string $errstr
+ * @param string $error_message
  * @return resource|false
  */
-function fsockopen(string $hostname, int $port = -1, &$errno = null, &$errstr = null, ?float $timeout = null) {}
+function fsockopen(string $hostname, int $port = -1, &$errno = null, &$error_message = null, ?float $timeout = null) {}
 
 /**
  * @param int $errno
- * @param string $errstr
+ * @param string $error_message
  * @return resource|false
  */
-function pfsockopen(string $hostname, int $port = -1, &$errno = null, &$errstr = null, ?float $timeout = null) {}
+function pfsockopen(string $hostname, int $port = -1, &$errno = null, &$error_message = null, ?float $timeout = null) {}
 
 /* http.c */
 
-function http_build_query(array|object $data, string $numeric_prefix = "", ?string $arg_separator = null, int $enc_type = PHP_QUERY_RFC1738): string {}
+function http_build_query(array|object $data, string $numeric_prefix = "", ?string $arg_separator = null, int $encoding_type = PHP_QUERY_RFC1738): string {}
 
 /* image.c */
 
@@ -982,18 +982,18 @@ function image_type_to_mime_type(int $image_type): string {}
 function image_type_to_extension(int $image_type, bool $include_dot = true): string|false {}
 
 /** @param array $image_info */
-function getimagesize(string $image_path, &$image_info = null): array|false {}
+function getimagesize(string $filename, &$image_info = null): array|false {}
 
 /** @param array $image_info */
-function getimagesizefromstring(string $image, &$image_info = null): array|false {}
+function getimagesizefromstring(string $string, &$image_info = null): array|false {}
 
 /* info.c */
 
-function phpinfo(int $what = INFO_ALL): bool {}
+function phpinfo(int $flags = INFO_ALL): bool {}
 
 function phpversion(?string $extension = null): string|false {}
 
-function phpcredits(int $flag = CREDITS_ALL): bool {}
+function phpcredits(int $flags = CREDITS_ALL): bool {}
 
 function php_sapi_name(): string|false {}
 
@@ -1005,13 +1005,13 @@ function php_ini_loaded_file(): string|false {}
 
 /* iptc.c */
 
-function iptcembed(string $iptcdata, string $jpeg_file_name, int $spool = 0): string|bool {}
+function iptcembed(string $iptc_data, string $filename, int $spool = 0): string|bool {}
 
-function iptcparse(string $iptcblock): array|false {}
+function iptcparse(string $iptc_block): array|false {}
 
 /* levenshtein.c */
 
-function levenshtein(string $str1, string $str2, int $cost_ins = 1, int $cost_rep = 1, int $cost_del = 1): int {}
+function levenshtein(string $string1, string $string2, int $insertion_cost = 1, int $repetition_cost = 1, int $deletion_cost = 1): int {}
 
 /* link.c */
 
@@ -1107,7 +1107,7 @@ function decoct(int $number): string {}
 
 function dechex(int $number): string {}
 
-function base_convert(string $number, int $frombase, int $tobase): string {}
+function base_convert(string $number, int $from_base, int $to_base): string {}
 
 function number_format(float $number, int $decimals = 0, ?string $decimal_point = "." , ?string $thousands_separator = ","): string {}
 
@@ -1118,20 +1118,20 @@ function fdiv(float $dividend, float $divisor): float {}
 /* microtime.c */
 
 #ifdef HAVE_GETTIMEOFDAY
-function microtime(bool $getAsFloat = false): string|float {}
+function microtime(bool $as_float = false): string|float {}
 
-function gettimeofday(bool $returnFloat = false): array|float {}
+function gettimeofday(bool $as_float = false): array|float {}
 #endif
 
 #ifdef HAVE_GETRUSAGE
-function getrusage(int $who = 0): array|false {}
+function getrusage(bool $mode = 0): array|false {}
 #endif
 
 /* pack.c */
 
-function pack(string $format, mixed ...$args): string {}
+function pack(string $format, mixed ...$values): string {}
 
-function unpack(string $format, string $data, int $offset = 0): array|false {}
+function unpack(string $format, string $string, int $offset = 0): array|false {}
 
 /* password.c */
 
@@ -1152,7 +1152,7 @@ function password_algos(): array {}
  * @param array $pipes
  * @return resource|false
  */
-function proc_open(array|string $cmd, array $descriptorspec, &$pipes, ?string $cwd = null, ?array $env = null, ?array $other_options = null) {}
+function proc_open(array|string $command, array $descriptor_spec, &$pipes, ?string $cwd = null, ?array $env = null, ?array $options = null) {}
 
 /** @param resource $process */
 function proc_close($process): int {}
@@ -1166,9 +1166,9 @@ function proc_get_status($process): array {}
 
 /* quot_print.c */
 
-function quoted_printable_decode(string $str): string {}
+function quoted_printable_decode(string $string): string {}
 
-function quoted_printable_encode(string $str): string {}
+function quoted_printable_encode(string $string): string {}
 
 /* mt_rand.c */
 
@@ -1198,7 +1198,7 @@ function soundex(string $string): string {}
 
 /* streamsfuncs.c */
 
-function stream_select(?array &$read, ?array &$write, ?array &$except, ?int $tv_sec, int $tv_usec = 0): int|false {}
+function stream_select(?array &$read, ?array &$write, ?array &$except, ?int $seconds, int $microsectons = 0): int|false {}
 
 /** @return resource */
 function stream_context_create(?array $options = null, ?array $params = null) {}
@@ -1225,43 +1225,43 @@ function stream_context_set_default(array $options) {}
  * @param resource $stream
  * @return resource|false
  */
-function stream_filter_prepend($stream, string $filtername, int $read_write = 0, mixed $params = UNKNOWN) {}
+function stream_filter_prepend($stream, string $filter_name, int $mode = 0, mixed $params = UNKNOWN) {}
 
 /**
  * @param resource $stream
  * @return resource|false
  */
-function stream_filter_append($stream, string $filtername, int $read_write = 0, mixed $params = UNKNOWN) {}
+function stream_filter_append($stream, string $filter_name, int $mode = 0, mixed $params = UNKNOWN) {}
 
 /** @param resource $stream_filter */
 function stream_filter_remove($stream_filter): bool {}
 
 /**
  * @param int $errno
- * @param string $errstr
+ * @param string $error_message
  * @param resource|null $context
  * @return resource|false
  */
-function stream_socket_client(string $remote_socket, &$errno = null, &$errstr = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null) {}
+function stream_socket_client(string $address, &$errno = null, &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null) {}
 
 /**
  * @param int $errno
- * @param string $errstr
+ * @param string $error_message
  * @param resource|null $context
  * @return resource|false
  */
-function stream_socket_server(string $local_socket, &$errno = null, &$errstr = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null) {}
+function stream_socket_server(string $address, &$errno = null, &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null) {}
 
 /**
- * @param resource $server_socket
+ * @param resource $socket
  * @param float $timeout
- * @param string $peername
+ * @param string $peer_name
  * @return resource|false
  */
-function stream_socket_accept($server_socket, ?float $timeout = null, &$peername = null) {}
+function stream_socket_accept($socket, ?float $timeout = null, &$peer_name = null) {}
 
-/** @param resource $handle */
-function stream_socket_get_name($handle, bool $want_peer): string|false {}
+/** @param resource $socket */
+function stream_socket_get_name($socket, bool $remote): string|false {}
 
 /**
  * @param resource $socket
@@ -1280,7 +1280,7 @@ function stream_socket_enable_crypto($stream, bool $enable, ?int $crypto_type =
 
 #ifdef HAVE_SHUTDOWN
 /** @param resource $stream */
-function stream_socket_shutdown($stream, int $how): bool {}
+function stream_socket_shutdown($stream, int $mode): bool {}
 #endif
 
 #if HAVE_SOCKETPAIR
@@ -1291,34 +1291,34 @@ function stream_socket_pair(int $domain, int $type, int $protocol): array|false
  * @param resource $source
  * @param resource $dest
  */
-function stream_copy_to_stream($source, $dest, ?int $maxlength = null, int $position = 0): int|false {}
+function stream_copy_to_stream($source, $dest, ?int $max_length = null, int $offset = 0): int|false {}
 
-/** @param resource $handle */
-function stream_get_contents($handle, ?int $maxlength = null, int $position = -1): string|false {}
+/** @param resource $stream */
+function stream_get_contents($stream, ?int $max_length = null, int $offset = -1): string|false {}
 
 /** @param resource $stream */
 function stream_supports_lock($stream): bool {}
 
 /** @param resource $stream */
-function stream_set_write_buffer($stream, int $buffer): int {}
+function stream_set_write_buffer($stream, int $size): int {}
 
 /**
  * @param resource $stream
  * @alias stream_set_write_buffer
  */
-function set_file_buffer($stream, int $buffer): int {}
+function set_file_buffer($stream, int $size): int {}
 
 /** @param resource $stream */
-function stream_set_read_buffer($stream, int $buffer): int {}
+function stream_set_read_buffer($stream, int $size): int {}
 
 /** @param resource $stream */
-function stream_set_blocking($stream, bool $mode): bool {}
+function stream_set_blocking($stream, bool $enable): bool {}
 
 /**
  * @param resource $stream
  * @alias stream_set_blocking
  */
-function socket_set_blocking($stream, bool $mode): bool {}
+function socket_set_blocking($stream, bool $enable): bool {}
 
 /** @param resource $stream */
 function stream_get_meta_data($stream): array {}
@@ -1329,8 +1329,8 @@ function stream_get_meta_data($stream): array {}
  */
 function socket_get_status($stream): array {}
 
-/** @param resource $handle */
-function stream_get_line($handle, int $max_length, string $ending = ""): string|false {}
+/** @param resource $stream */
+function stream_get_line($stream, int $max_length, string $ending = ""): string|false {}
 
 function stream_resolve_include_path(string $filename): string|false {}
 
@@ -1353,21 +1353,21 @@ function sapi_windows_vt100_support($stream, ?bool $enable = null): bool {}
 function stream_set_chunk_size($stream, int $size): int {}
 
 #if HAVE_SYS_TIME_H || defined(PHP_WIN32)
-/** @param resource $socket */
-function stream_set_timeout($socket, int $seconds, int $microseconds = 0): bool {}
+/** @param resource $stream */
+function stream_set_timeout($stream, int $seconds, int $microseconds = 0): bool {}
 
 /**
- * @param resource $socket
+ * @param resource $stream
  * @alias stream_set_timeout
  */
-function socket_set_timeout($socket, int $seconds, int $microseconds = 0): bool {}
+function socket_set_timeout($stream, int $seconds, int $microseconds = 0): bool {}
 #endif
 
 /* type.c */
 
-function gettype(mixed $var): string {}
+function gettype(mixed $value): string {}
 
-function get_debug_type(mixed $var): string {}
+function get_debug_type(mixed $value): string {}
 
 function settype(mixed &$var, string $type): bool {}
 
@@ -1438,7 +1438,8 @@ function rawurlencode(string $string): string {}
 function rawurldecode(string $string): string {}
 
 /** @param resource $context */
-function get_headers(string $url, int $format = 0, $context = null): array|false {}
+// TODO: Make bool argument?
+function get_headers(string $url, int $as_assoc_array = 0, $context = null): array|false {}
 
 /* user_filters.c */
 
@@ -1456,13 +1457,13 @@ function stream_bucket_new($stream, string $buffer): object {}
 
 function stream_get_filters(): array {}
 
-function stream_filter_register(string $filtername, string $classname): bool {}
+function stream_filter_register(string $filter_name, string $class): bool {}
 
 /* uuencode.c */
 
-function convert_uuencode(string $data): string {}
+function convert_uuencode(string $string): string {}
 
-function convert_uudecode(string $data): string|false {}
+function convert_uudecode(string $string): string|false {}
 
 /* var.c */
 
@@ -1487,7 +1488,7 @@ function version_compare(string $version1, string $version2, ?string $operator =
 /* win32/codepage.c */
 
 #ifdef PHP_WIN32
-function sapi_windows_cp_set(int $cp): bool {}
+function sapi_windows_cp_set(int $codepage): bool {}
 
 function sapi_windows_cp_get(string $kind = ""): int {}
 
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index e3f8d508e1bc8..5f766ad54fc97 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 5e2daf7a5fb04bafdc57b7d3668b94fe573b8b2e */
+ * Stub hash: 4eeaf5c6c4a570c38577fc8d0047e2437f542074 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -10,7 +10,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_header_register_callback, 0, 1,
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ob_start, 0, 0, _IS_BOOL, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, user_function, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, callback, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, chunk_size, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "PHP_OUTPUT_HANDLER_STDFLAGS")
 ZEND_END_ARG_INFO()
@@ -45,7 +45,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ob_get_status, 0, 0, IS_ARRAY, 0
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ob_implicit_flush, 0, 0, IS_VOID, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flag, _IS_BOOL, 0, "true")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enable, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
 #define arginfo_output_reset_rewrite_vars arginfo_ob_flush
@@ -57,7 +57,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_wrapper_register, 0, 2, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, protocol, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, classname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, class, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
@@ -82,7 +82,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_ksort arginfo_krsort
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_count, 0, 1, IS_LONG, 0)
-	ZEND_ARG_OBJ_TYPE_MASK(0, var, Countable, MAY_BE_ARRAY, NULL)
+	ZEND_ARG_OBJ_TYPE_MASK(0, value, Countable, MAY_BE_ARRAY, NULL)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "COUNT_NORMAL")
 ZEND_END_ARG_INFO()
 
@@ -112,7 +112,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_uksort arginfo_usort
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_end, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_MASK(1, arg, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
+	ZEND_ARG_TYPE_MASK(1, array, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
 ZEND_END_ARG_INFO()
 
 #define arginfo_prev arginfo_end
@@ -122,13 +122,13 @@ ZEND_END_ARG_INFO()
 #define arginfo_reset arginfo_end
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_current, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_MASK(0, arg, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
+	ZEND_ARG_TYPE_MASK(0, array, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
 ZEND_END_ARG_INFO()
 
 #define arginfo_pos arginfo_current
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_key, 0, 1, MAY_BE_LONG|MAY_BE_STRING|MAY_BE_NULL)
-	ZEND_ARG_TYPE_MASK(0, arg, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
+	ZEND_ARG_TYPE_MASK(0, array, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_min, 0, 1, IS_MIXED, 0)
@@ -160,7 +160,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_extract, 0, 1, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(ZEND_SEND_PREFER_REF, array, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, extract_type, IS_LONG, 0, "EXTR_OVERWRITE")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "EXTR_OVERWRITE")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, prefix, IS_STRING, 0, "\"\"")
 ZEND_END_ARG_INFO()
 
@@ -170,8 +170,8 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_compact, 0, 1, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_fill, 0, 3, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, start_key, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, start, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
@@ -181,26 +181,29 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_fill_keys, 0, 2, IS_ARRAY,
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_range, 0, 2, IS_ARRAY, 0)
-	ZEND_ARG_INFO(0, low)
-	ZEND_ARG_INFO(0, high)
+	ZEND_ARG_INFO(0, start)
+	ZEND_ARG_INFO(0, end)
 	ZEND_ARG_TYPE_MASK(0, step, MAY_BE_LONG|MAY_BE_DOUBLE, "1")
 ZEND_END_ARG_INFO()
 
 #define arginfo_shuffle arginfo_natsort
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_pop, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(1, stack, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_array_shift arginfo_array_pop
 
-#define arginfo_array_unshift arginfo_array_push
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_unshift, 0, 1, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_splice, 0, 2, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, replacements, IS_MIXED, 0, "[]")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, replacement, IS_MIXED, 0, "[]")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_slice, 0, 2, IS_ARRAY, 0)
@@ -254,8 +257,8 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_pad, 0, 3, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, array, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, pad_size, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, pad_value, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_array_flip arginfo_array_values
@@ -309,13 +312,13 @@ ZEND_END_ARG_INFO()
 #define arginfo_array_udiff_uassoc arginfo_array_intersect_ukey
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_multisort, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_INFO(ZEND_SEND_PREFER_REF, array1)
+	ZEND_ARG_INFO(ZEND_SEND_PREFER_REF, array)
 	ZEND_ARG_VARIADIC_INFO(ZEND_SEND_PREFER_REF, rest)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_array_rand, 0, 1, MAY_BE_LONG|MAY_BE_STRING|MAY_BE_ARRAY)
 	ZEND_ARG_TYPE_INFO(0, array, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, num_req, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, num, IS_LONG, 0, "1")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_array_sum, 0, 1, MAY_BE_LONG|MAY_BE_DOUBLE)
@@ -351,7 +354,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_chunk, 0, 2, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, array, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, preserve_keys, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
@@ -361,11 +364,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_combine, 0, 2, IS_ARRAY, 0
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_base64_encode, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_base64_decode, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, strict, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
@@ -378,11 +381,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ip2long, 0, 1, MAY_BE_LONG|MAY_B
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_long2ip, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, proper_address, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, ip_address, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getenv, 0, 0, MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, variable, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, name, IS_STRING, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, local_only, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
@@ -394,8 +397,8 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getopt, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, options, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, longopts, IS_ARRAY, 0, "[]")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, optind, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, long_options, IS_ARRAY, 0, "[]")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, rest_index, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_flush, 0, 0, IS_VOID, 0)
@@ -426,7 +429,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_get_current_user, 0, 0, IS_STRIN
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_get_cfg_var, 0, 1, MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, option_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_error_log, 0, 1, _IS_BOOL, 0)
@@ -442,12 +445,12 @@ ZEND_END_ARG_INFO()
 #define arginfo_error_clear_last arginfo_flush
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_call_user_func, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, function, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
 	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_call_user_func_array, 0, 2, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, function, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
 	ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
@@ -456,7 +459,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_forward_static_call_array arginfo_call_user_func_array
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_register_shutdown_function, 0, 1, _IS_BOOL, 1)
-	ZEND_ARG_TYPE_INFO(0, function, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
 	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
@@ -477,7 +480,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_highlight_string, 0, 1, MAY_BE_S
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ini_get, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, varname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ini_get_all, 0, 0, MAY_BE_ARRAY|MAY_BE_FALSE)
@@ -486,14 +489,14 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ini_get_all, 0, 0, MAY_BE_ARRAY|
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ini_set, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, varname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_ini_alter arginfo_ini_set
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ini_restore, 0, 1, IS_VOID, 0)
-	ZEND_ARG_TYPE_INFO(0, varname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_set_include_path, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
@@ -503,7 +506,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_get_include_path arginfo_ob_get_flush
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_print_r, 0, 1, MAY_BE_STRING|MAY_BE_BOOL)
-	ZEND_ARG_TYPE_INFO(0, var, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, return, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
@@ -512,7 +515,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_connection_status arginfo_ob_get_level
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ignore_user_abort, 0, 0, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, value, _IS_BOOL, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enable, _IS_BOOL, 1, "null")
 ZEND_END_ARG_INFO()
 
 #if HAVE_GETSERVBYNAME
@@ -531,7 +534,7 @@ ZEND_END_ARG_INFO()
 
 #if HAVE_GETPROTOBYNAME
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getprotobyname, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, protocol, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
@@ -542,12 +545,12 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_register_tick_function, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, function, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
 	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_unregister_tick_function, 0, 1, IS_VOID, 0)
-	ZEND_ARG_TYPE_INFO(0, function, IS_CALLABLE, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_is_uploaded_file, 0, 1, _IS_BOOL, 0)
@@ -582,16 +585,16 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_get_browser, 0, 0, MAY_BE_OBJECT|MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, browser_name, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, user_agent, IS_STRING, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, return_array, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_crc32, 0, 1, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_crypt, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, salt, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
@@ -634,8 +637,8 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_dns_get_record, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, hostname, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, type, IS_LONG, 0, "DNS_ANY")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, authns, "null")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, addtl, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, authoritative_name_servers, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, additional_records, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, raw, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 #endif
@@ -643,8 +646,8 @@ ZEND_END_ARG_INFO()
 #if defined(PHP_WIN32) || HAVE_DNS_SEARCH_FUNC
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_dns_get_mx, 0, 2, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, hostname, IS_STRING, 0)
-	ZEND_ARG_INFO(1, mxhosts)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, weight, "null")
+	ZEND_ARG_INFO(1, hosts)
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, weights, "null")
 ZEND_END_ARG_INFO()
 #endif
 
@@ -657,26 +660,26 @@ ZEND_END_ARG_INFO()
 
 #if HAVE_FTOK
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ftok, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, pathname, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, proj, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, project_id, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_hrtime, 0, 0, MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, get_as_number, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, as_number, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_lcg_value, 0, 0, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_md5, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, raw_output, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, binary, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_md5_file, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, raw_output, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, binary, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
 #define arginfo_getmyuid arginfo_ob_get_length
@@ -695,8 +698,8 @@ ZEND_END_ARG_INFO()
 
 #if defined(HAVE_SYSLOG_H)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openlog, 0, 3, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, ident, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, flags, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, facility, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 #endif
@@ -715,7 +718,7 @@ ZEND_END_ARG_INFO()
 
 #if defined(HAVE_INET_NTOP)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_inet_ntop, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, in_addr, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, ip_address, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
@@ -726,12 +729,12 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_metaphone, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, text, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, phonemes, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_phonemes, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_header, 0, 1, IS_VOID, 0)
-	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, header, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, replace, _IS_BOOL, 0, "true")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, http_response_code, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
@@ -765,19 +768,19 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_htmlspecialchars, 0, 1, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, quote_style, IS_LONG, 0, "ENT_COMPAT")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "ENT_COMPAT")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, encoding, IS_STRING, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, double_encode, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_htmlspecialchars_decode, 0, 1, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, quote_style, IS_LONG, 0, "ENT_COMPAT")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "ENT_COMPAT")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_html_entity_decode, 0, 1, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, quote_style, IS_LONG, 0, "ENT_COMPAT")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "ENT_COMPAT")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, encoding, IS_STRING, 1, "null")
 ZEND_END_ARG_INFO()
 
@@ -785,7 +788,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_get_html_translation_table, 0, 0, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, table, IS_LONG, 0, "HTML_SPECIALCHARS")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, quote_style, IS_LONG, 0, "ENT_COMPAT")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "ENT_COMPAT")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, encoding, IS_STRING, 0, "\"UTF-8\"")
 ZEND_END_ARG_INFO()
 
@@ -795,23 +798,21 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_assert, 0, 1, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_assert_options, 0, 1, MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_LONG|MAY_BE_STRING|MAY_BE_NULL)
-	ZEND_ARG_TYPE_INFO(0, what, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, option, IS_LONG, 0)
 	ZEND_ARG_INFO(0, value)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_bin2hex, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, data, IS_STRING, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_bin2hex arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_hex2bin, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, data, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strspn, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, mask, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, characters, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, start, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, len, IS_LONG, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 #define arginfo_strcspn arginfo_strspn
@@ -823,13 +824,13 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strcoll, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, str1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str2, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string1, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string2, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_trim, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, character_mask, IS_STRING, 0, "\" \\n\\r\\t\\v\\0\"")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, characters, IS_STRING, 0, "\" \\n\\r\\t\\v\\0\"")
 ZEND_END_ARG_INFO()
 
 #define arginfo_rtrim arginfo_trim
@@ -839,27 +840,27 @@ ZEND_END_ARG_INFO()
 #define arginfo_ltrim arginfo_trim
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_wordwrap, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, width, IS_LONG, 0, "75")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, break, IS_STRING, 0, "\"\\n\"")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cut, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cut_long_words, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_explode, 0, 2, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, separator, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, limit, IS_LONG, 0, "PHP_INT_MAX")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_implode, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_MASK(0, glue, MAY_BE_STRING|MAY_BE_ARRAY, NULL)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, pieces, IS_ARRAY, 1, "null")
+	ZEND_ARG_TYPE_MASK(0, separator, MAY_BE_STRING|MAY_BE_ARRAY, NULL)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, array, IS_ARRAY, 1, "null")
 ZEND_END_ARG_INFO()
 
 #define arginfo_join arginfo_implode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_strtok, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, token, IS_STRING, 1, "null")
 ZEND_END_ARG_INFO()
 
@@ -879,7 +880,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_pathinfo, 0, 1, MAY_BE_ARRAY|MAY_BE_STRING)
 	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_LONG, 0, "PATHINFO_ALL")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "PATHINFO_ALL")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stristr, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
@@ -919,19 +920,19 @@ ZEND_END_ARG_INFO()
 #define arginfo_str_ends_with arginfo_str_contains
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_chunk_split, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, chunklen, IS_LONG, 0, "76")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, ending, IS_STRING, 0, "\"\\r\\n\"")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 0, "76")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, separator, IS_STRING, 0, "\"\\r\\n\"")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, start, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_substr_replace, 0, 3, MAY_BE_STRING|MAY_BE_ARRAY)
-	ZEND_ARG_TYPE_MASK(0, str, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
+	ZEND_ARG_TYPE_MASK(0, string, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
 	ZEND_ARG_TYPE_MASK(0, replace, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
 	ZEND_ARG_TYPE_MASK(0, start, MAY_BE_ARRAY|MAY_BE_LONG, NULL)
 	ZEND_ARG_TYPE_MASK(0, length, MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_NULL, "null")
@@ -952,12 +953,12 @@ ZEND_END_ARG_INFO()
 #define arginfo_lcfirst arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ucwords, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiters, IS_STRING, 0, "\" \\t\\r\\n\\f\\v\"")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strtr, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_MASK(0, from, MAY_BE_STRING|MAY_BE_ARRAY, NULL)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, to, IS_STRING, 1, "null")
 ZEND_END_ARG_INFO()
@@ -965,14 +966,14 @@ ZEND_END_ARG_INFO()
 #define arginfo_strrev arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_similar_text, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, str1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str2, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string1, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string2, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, percent, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_addcslashes, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, charlist, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, characters, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_addslashes arginfo_base64_encode
@@ -985,24 +986,24 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_str_replace, 0, 3, MAY_BE_STRING
 	ZEND_ARG_TYPE_MASK(0, search, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
 	ZEND_ARG_TYPE_MASK(0, replace, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
 	ZEND_ARG_TYPE_MASK(0, subject, MAY_BE_STRING|MAY_BE_ARRAY, NULL)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, replace_count, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, count, "null")
 ZEND_END_ARG_INFO()
 
 #define arginfo_str_ireplace arginfo_str_replace
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_hebrev, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_chars_per_line, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_nl2br, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, is_xhtml, _IS_BOOL, 0, "true")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_xhtml, _IS_BOOL, 0, "true")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strip_tags, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
-	ZEND_ARG_TYPE_MASK(0, allowable_tags, MAY_BE_ARRAY|MAY_BE_STRING|MAY_BE_NULL, "null")
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_MASK(0, allowed_tags, MAY_BE_ARRAY|MAY_BE_STRING|MAY_BE_NULL, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_setlocale, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
@@ -1024,23 +1025,20 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_str_getcsv, 0, 1, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_str_repeat, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, input, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, mult, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, times, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_count_chars, 0, 1, MAY_BE_ARRAY|MAY_BE_STRING)
-	ZEND_ARG_TYPE_INFO(0, input, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strnatcmp, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, s1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, s2, IS_STRING, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_strnatcmp arginfo_strcoll
 
 #define arginfo_localeconv arginfo_ob_list_handlers
 
-#define arginfo_strnatcasecmp arginfo_strnatcmp
+#define arginfo_strnatcasecmp arginfo_strcoll
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr_count, 0, 2, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, haystack, IS_STRING, 0)
@@ -1050,14 +1048,14 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr_count, 0, 2, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_str_pad, 0, 2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, input, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, pad_length, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, pad_string, IS_STRING, 0, "\" \"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, pad_type, IS_LONG, 0, "STR_PAD_RIGHT")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_sscanf, 0, 2, MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_NULL)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
 	ZEND_ARG_VARIADIC_TYPE_INFO(1, vars, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
@@ -1067,32 +1065,32 @@ ZEND_END_ARG_INFO()
 #define arginfo_str_shuffle arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_str_word_count, 0, 1, MAY_BE_ARRAY|MAY_BE_LONG)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, format, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, charlist, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, characters, IS_STRING, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_str_split, 0, 1, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 0, "1")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_strpbrk, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, haystack, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, char_list, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, characters, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr_compare, 0, 3, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, main_str, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, main_string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, case_insensitivity, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, case_insensitive, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 
-#define arginfo_utf8_encode arginfo_bin2hex
+#define arginfo_utf8_encode arginfo_base64_encode
 
-#define arginfo_utf8_decode arginfo_bin2hex
+#define arginfo_utf8_decode arginfo_base64_encode
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_opendir, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
@@ -1176,9 +1174,9 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_flock, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, operation, IS_LONG, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, wouldblock, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, would_block, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_get_meta_tags, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
@@ -1202,11 +1200,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_readfile, 0, 1, MAY_BE_LONG|MAY_
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rewind, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rmdir, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, dirname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
@@ -1219,16 +1217,16 @@ ZEND_END_ARG_INFO()
 #define arginfo_feof arginfo_rewind
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fgetc, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fgets, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fread, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
@@ -1242,50 +1240,52 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fscanf, 0, 2, MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_FALSE|MAY_BE_NULL)
 	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(1, args, IS_MIXED, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(1, vars, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
-#define arginfo_fpassthru arginfo_pclose
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_fpassthru, 0, 1, IS_LONG, 0)
+	ZEND_ARG_INFO(0, stream)
+ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ftruncate, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fstat, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_fseek, 0, 2, IS_LONG, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, whence, IS_LONG, 0, "SEEK_SET")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ftell, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 ZEND_END_ARG_INFO()
 
 #define arginfo_fflush arginfo_rewind
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fwrite, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
-	ZEND_ARG_TYPE_INFO(0, content, IS_STRING, 0)
+	ZEND_ARG_INFO(0, stream)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 #define arginfo_fputs arginfo_fwrite
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_mkdir, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, pathname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "0777")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, recursive, _IS_BOOL, 0, "false")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rename, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, oldname, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, newname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, old_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, new_name, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
@@ -1296,7 +1296,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_copy, 0, 2, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_tempnam, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, dir, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, prefix, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
@@ -1314,7 +1314,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_file_get_contents, 0, 1, MAY_BE_
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_include_path, _IS_BOOL, 0, "false")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, maxlen, IS_LONG, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_unlink, 0, 1, _IS_BOOL, 0)
@@ -1330,7 +1330,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_file_put_contents, 0, 2, MAY_BE_
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fputcsv, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, fields, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiter, IS_STRING, 0, "\",\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enclosure, IS_STRING, 0, "\"\\\"\"")
@@ -1338,7 +1338,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fputcsv, 0, 2, MAY_BE_LONG|MAY_B
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fgetcsv, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiter, IS_STRING, 0, "\",\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enclosure, IS_STRING, 0, "\"\\\"\"")
@@ -1437,7 +1437,7 @@ ZEND_END_ARG_INFO()
 #if HAVE_UTIME
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_touch, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, time, IS_LONG, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mtime, IS_LONG, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, atime, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 #endif
@@ -1461,41 +1461,41 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sprintf, 0, 1, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_printf, 0, 1, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_vprintf, 0, 2, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, values, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_vsprintf, 0, 2, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, values, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_fprintf, 0, 2, IS_LONG, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_vfprintf, 0, 3, IS_LONG, 0)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, values, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_fsockopen, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, hostname, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, port, IS_LONG, 0, "-1")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errstr, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, timeout, IS_DOUBLE, 1, "null")
 ZEND_END_ARG_INFO()
 
@@ -1505,7 +1505,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_http_build_query, 0, 1, IS_STRIN
 	ZEND_ARG_TYPE_MASK(0, data, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, numeric_prefix, IS_STRING, 0, "\"\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, arg_separator, IS_STRING, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enc_type, IS_LONG, 0, "PHP_QUERY_RFC1738")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, encoding_type, IS_LONG, 0, "PHP_QUERY_RFC1738")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_image_type_to_mime_type, 0, 1, IS_STRING, 0)
@@ -1518,17 +1518,17 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_image_type_to_extension, 0, 1, M
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getimagesize, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, image_path, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, image_info, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getimagesizefromstring, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, image, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, image_info, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phpinfo, 0, 0, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, what, IS_LONG, 0, "INFO_ALL")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "INFO_ALL")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_phpversion, 0, 0, MAY_BE_STRING|MAY_BE_FALSE)
@@ -1536,7 +1536,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_phpversion, 0, 0, MAY_BE_STRING|
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_phpcredits, 0, 0, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flag, IS_LONG, 0, "CREDITS_ALL")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "CREDITS_ALL")
 ZEND_END_ARG_INFO()
 
 #define arginfo_php_sapi_name arginfo_ob_get_flush
@@ -1550,21 +1550,21 @@ ZEND_END_ARG_INFO()
 #define arginfo_php_ini_loaded_file arginfo_ob_get_flush
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_iptcembed, 0, 2, MAY_BE_STRING|MAY_BE_BOOL)
-	ZEND_ARG_TYPE_INFO(0, iptcdata, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, jpeg_file_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, iptc_data, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, spool, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_iptcparse, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, iptcblock, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, iptc_block, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_levenshtein, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, str1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, str2, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cost_ins, IS_LONG, 0, "1")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cost_rep, IS_LONG, 0, "1")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cost_del, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO(0, string1, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string2, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, insertion_cost, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, repetition_cost, IS_LONG, 0, "1")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, deletion_cost, IS_LONG, 0, "1")
 ZEND_END_ARG_INFO()
 
 #if defined(HAVE_SYMLINK) || defined(PHP_WIN32)
@@ -1711,8 +1711,8 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_base_convert, 0, 3, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, number, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, frombase, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, tobase, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, from_base, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, to_base, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_number_format, 0, 1, IS_STRING, 0)
@@ -1731,19 +1731,19 @@ ZEND_END_ARG_INFO()
 
 #if defined(HAVE_GETTIMEOFDAY)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_microtime, 0, 0, MAY_BE_STRING|MAY_BE_DOUBLE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, getAsFloat, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, as_float, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 #endif
 
 #if defined(HAVE_GETTIMEOFDAY)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_gettimeofday, 0, 0, MAY_BE_ARRAY|MAY_BE_DOUBLE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, returnFloat, _IS_BOOL, 0, "false")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, as_float, _IS_BOOL, 0, "false")
 ZEND_END_ARG_INFO()
 #endif
 
 #if defined(HAVE_GETRUSAGE)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getrusage, 0, 0, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, who, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, _IS_BOOL, 0, "0")
 ZEND_END_ARG_INFO()
 #endif
 
@@ -1751,7 +1751,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_unpack, 0, 2, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, format, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, data, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
@@ -1780,12 +1780,12 @@ ZEND_END_ARG_INFO()
 
 #if defined(PHP_CAN_SUPPORT_PROC_OPEN)
 ZEND_BEGIN_ARG_INFO_EX(arginfo_proc_open, 0, 0, 3)
-	ZEND_ARG_TYPE_MASK(0, cmd, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
-	ZEND_ARG_TYPE_INFO(0, descriptorspec, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_MASK(0, command, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
+	ZEND_ARG_TYPE_INFO(0, descriptor_spec, IS_ARRAY, 0)
 	ZEND_ARG_INFO(1, pipes)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cwd, IS_STRING, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, env, IS_ARRAY, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, other_options, IS_ARRAY, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 1, "null")
 ZEND_END_ARG_INFO()
 #endif
 
@@ -1839,16 +1839,14 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_random_int, 0, 2, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, max, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_soundex, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_soundex arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_select, 0, 4, MAY_BE_LONG|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(1, read, IS_ARRAY, 1)
 	ZEND_ARG_TYPE_INFO(1, write, IS_ARRAY, 1)
 	ZEND_ARG_TYPE_INFO(1, except, IS_ARRAY, 1)
-	ZEND_ARG_TYPE_INFO(0, tv_sec, IS_LONG, 1)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, tv_usec, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 1)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, microsectons, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_context_create, 0, 0, 0)
@@ -1886,8 +1884,8 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_filter_prepend, 0, 0, 2)
 	ZEND_ARG_INFO(0, stream)
-	ZEND_ARG_TYPE_INFO(0, filtername, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, read_write, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO(0, filter_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO(0, params, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
@@ -1898,31 +1896,31 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_filter_remove, 0, 1, _IS_
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_socket_client, 0, 0, 1)
-	ZEND_ARG_TYPE_INFO(0, remote_socket, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errstr, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, timeout, IS_DOUBLE, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "STREAM_CLIENT_CONNECT")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_socket_server, 0, 0, 1)
-	ZEND_ARG_TYPE_INFO(0, local_socket, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errstr, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "STREAM_SERVER_BIND | STREAM_SERVER_LISTEN")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_socket_accept, 0, 0, 1)
-	ZEND_ARG_INFO(0, server_socket)
+	ZEND_ARG_INFO(0, socket)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, timeout, IS_DOUBLE, 1, "null")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, peername, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, peer_name, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_socket_get_name, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
-	ZEND_ARG_TYPE_INFO(0, want_peer, _IS_BOOL, 0)
+	ZEND_ARG_INFO(0, socket)
+	ZEND_ARG_TYPE_INFO(0, remote, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_socket_recvfrom, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
@@ -1949,7 +1947,7 @@ ZEND_END_ARG_INFO()
 #if defined(HAVE_SHUTDOWN)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_socket_shutdown, 0, 2, _IS_BOOL, 0)
 	ZEND_ARG_INFO(0, stream)
-	ZEND_ARG_TYPE_INFO(0, how, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, mode, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 #endif
 
@@ -1964,23 +1962,21 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_copy_to_stream, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
 	ZEND_ARG_INFO(0, source)
 	ZEND_ARG_INFO(0, dest)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, maxlength, IS_LONG, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, position, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_length, IS_LONG, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_get_contents, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, maxlength, IS_LONG, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, position, IS_LONG, 0, "-1")
-ZEND_END_ARG_INFO()
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_supports_lock, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_INFO(0, stream)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_length, IS_LONG, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "-1")
 ZEND_END_ARG_INFO()
 
+#define arginfo_stream_supports_lock arginfo_rewind
+
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_set_write_buffer, 0, 2, IS_LONG, 0)
 	ZEND_ARG_INFO(0, stream)
-	ZEND_ARG_TYPE_INFO(0, buffer, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_set_file_buffer arginfo_stream_set_write_buffer
@@ -1989,7 +1985,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_set_blocking, 0, 2, _IS_BOOL, 0)
 	ZEND_ARG_INFO(0, stream)
-	ZEND_ARG_TYPE_INFO(0, mode, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, enable, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_socket_set_blocking arginfo_stream_set_blocking
@@ -2001,7 +1997,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_socket_get_status arginfo_stream_get_meta_data
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_get_line, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, handle)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, max_length, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, ending, IS_STRING, 0, "\"\"")
 ZEND_END_ARG_INFO()
@@ -2012,9 +2008,9 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_stream_get_transports arginfo_ob_list_handlers
 
-#define arginfo_stream_is_local arginfo_stream_supports_lock
+#define arginfo_stream_is_local arginfo_rewind
 
-#define arginfo_stream_isatty arginfo_stream_supports_lock
+#define arginfo_stream_isatty arginfo_rewind
 
 #if defined(PHP_WIN32)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sapi_windows_vt100_support, 0, 1, _IS_BOOL, 0)
@@ -2023,14 +2019,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sapi_windows_vt100_support, 0, 1
 ZEND_END_ARG_INFO()
 #endif
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_set_chunk_size, 0, 2, IS_LONG, 0)
-	ZEND_ARG_INFO(0, stream)
-	ZEND_ARG_TYPE_INFO(0, size, IS_LONG, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_stream_set_chunk_size arginfo_stream_set_write_buffer
 
 #if HAVE_SYS_TIME_H || defined(PHP_WIN32)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_set_timeout, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_INFO(0, socket)
+	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, microseconds, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
@@ -2041,7 +2034,7 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_gettype, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, var, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_get_debug_type arginfo_gettype
@@ -2066,9 +2059,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_boolval, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strval, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_strval arginfo_gettype
 
 #define arginfo_is_null arginfo_boolval
 
@@ -2118,17 +2109,17 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_parse_url, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, component, IS_LONG, 0, "-1")
 ZEND_END_ARG_INFO()
 
-#define arginfo_urlencode arginfo_soundex
+#define arginfo_urlencode arginfo_base64_encode
 
-#define arginfo_urldecode arginfo_soundex
+#define arginfo_urldecode arginfo_base64_encode
 
-#define arginfo_rawurlencode arginfo_soundex
+#define arginfo_rawurlencode arginfo_base64_encode
 
-#define arginfo_rawurldecode arginfo_soundex
+#define arginfo_rawurldecode arginfo_base64_encode
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_get_headers, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, url, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, format, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, as_assoc_array, IS_LONG, 0, "0")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
@@ -2151,11 +2142,11 @@ ZEND_END_ARG_INFO()
 #define arginfo_stream_get_filters arginfo_ob_list_handlers
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_stream_filter_register, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, filtername, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, classname, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filter_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, class, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
-#define arginfo_convert_uuencode arginfo_bin2hex
+#define arginfo_convert_uuencode arginfo_base64_encode
 
 #define arginfo_convert_uudecode arginfo_hex2bin
 
@@ -2171,7 +2162,7 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_debug_zval_dump arginfo_var_dump
 
-#define arginfo_serialize arginfo_strval
+#define arginfo_serialize arginfo_gettype
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_unserialize, 0, 1, IS_MIXED, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
@@ -2192,7 +2183,7 @@ ZEND_END_ARG_INFO()
 
 #if defined(PHP_WIN32)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sapi_windows_cp_set, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, cp, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, codepage, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 #endif
 

From b3b972892f2d1cc62d86eb757e485b2e63b26ca2 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Mon, 28 Sep 2020 11:38:09 +0200
Subject: [PATCH 02/10] Some updates

---
 ext/standard/basic_functions.stub.php  | 58 +++++++++---------
 ext/standard/basic_functions_arginfo.h | 83 ++++++++++++--------------
 2 files changed, 68 insertions(+), 73 deletions(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index 18deafa13df7f..a25d5fb425677 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -56,7 +56,7 @@ function stream_wrapper_restore(string $protocol): bool {}
 
 /* array.c */
 
-function array_push(array &$stack, mixed ...$values): int {}
+function array_push(array &$array, mixed ...$values): int {}
 
 function krsort(array &$array, int $flags = SORT_REGULAR): bool {}
 
@@ -100,13 +100,13 @@ function pos(array|object $array): mixed {}
 
 function key(array|object $array): int|string|null {}
 
-function min(mixed $arg, mixed ...$args): mixed {}
+function min(mixed $value, mixed ...$values): mixed {}
 
-function max(mixed $arg, mixed ...$args): mixed {}
+function max(mixed $value, mixed ...$values): mixed {}
 
-function array_walk(array|object &$input, callable $callback, mixed $argument = UNKNOWN): bool {}
+function array_walk(array|object &$array, callable $callback, mixed $arg = UNKNOWN): bool {}
 
-function array_walk_recursive(array|object &$input, callable $callback, mixed $argument = UNKNOWN): bool {}
+function array_walk_recursive(array|object &$array, callable $callback, mixed $arg = UNKNOWN): bool {}
 
 function in_array(mixed $needle, array $haystack, bool $strict = false): bool {}
 
@@ -121,7 +121,7 @@ function extract(array &$array, int $flags = EXTR_OVERWRITE, string $prefix = ""
  */
 function compact($var_name, ...$var_names): array {}
 
-function array_fill(int $start, int $length, mixed $value): array {}
+function array_fill(int $start, int $count, mixed $value): array {}
 
 function array_fill_keys(array $keys, mixed $value): array {}
 
@@ -231,7 +231,7 @@ function array_product(array $array): int|float {}
 
 function array_reduce(array $array, callable $callback, mixed $initial = null): mixed {}
 
-function array_filter(array $array, ?callable $callback = null, int $use_keys = 0): array {}
+function array_filter(array $array, ?callable $callback = null, int $mode = 0): array {}
 
 function array_map(?callable $callback, array $array, array ...$arrays): array {}
 
@@ -258,18 +258,18 @@ function base64_decode(string $string, bool $strict = false): string|false {}
 
 function constant(string $name): mixed {}
 
-function ip2long(string $ip_address): int|false {}
+function ip2long(string $ip): int|false {}
 
-function long2ip(int $ip_address): string|false {}
+function long2ip(int $ip): string|false {}
 
 function getenv(?string $name = null, bool $local_only = false): string|array|false {}
 
 #ifdef HAVE_PUTENV
-function putenv(string $setting): bool {}
+function putenv(string $assignment): bool {}
 #endif
 
 /** @param int $rest_index */
-function getopt(string $options, array $long_options = [], &$rest_index = null): array|false {}
+function getopt(string $short_options, array $long_options = [], &$rest_index = null): array|false {}
 
 function flush(): void {}
 
@@ -287,7 +287,7 @@ function get_current_user(): string {}
 
 function get_cfg_var(string $name): string|array|false {}
 
-function error_log(string $message, int $message_type = 0, ?string $destination = null, ?string $extra_headers = null): bool {}
+function error_log(string $message, int $message_type = 0, ?string $destination = null, ?string $additional_headers = null): bool {}
 
 function error_get_last(): ?array {}
 
@@ -355,9 +355,9 @@ function register_tick_function(callable $callback, mixed ...$args): bool {}
 
 function unregister_tick_function(callable $callback): void {}
 
-function is_uploaded_file(string $path): bool {}
+function is_uploaded_file(string $filename): bool {}
 
-function move_uploaded_file(string $path, string $new_path): bool {}
+function move_uploaded_file(string $filename, string $new_filename): bool {}
 
 function parse_ini_file(string $filename, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false {}
 
@@ -395,7 +395,7 @@ function strptime(string $timestamp, string $format): array|false {}
 function gethostname(): string|false {}
 #endif
 
-function gethostbyaddr(string $ip_address): string|false {}
+function gethostbyaddr(string $ip): string|false {}
 
 function gethostbyname(string $hostname): string {}
 
@@ -480,11 +480,11 @@ function syslog(int $priority, string $message): bool {}
 #endif
 
 #ifdef HAVE_INET_NTOP
-function inet_ntop(string $ip_address): string|false {}
+function inet_ntop(string $ip): string|false {}
 #endif
 
 #ifdef HAVE_INET_PTON
-function inet_pton(string $ip_address): string|false {}
+function inet_pton(string $ip): string|false {}
 #endif
 
 /* metaphone.c */
@@ -492,7 +492,7 @@ function inet_pton(string $ip_address): string|false {}
 function metaphone(string $string, int $max_phonemes = 0): string {}
 
 /* {{{ head.c */
-function header(string $header, bool $replace = true, int $http_response_code = 0): void {}
+function header(string $header, bool $replace = true, int $response_code = 0): void {}
 
 function header_remove(?string $name = null): void {}
 
@@ -503,10 +503,10 @@ function setcookie(string $name, string $value = "", array|int $expires_or_optio
 function http_response_code(int $response_code = 0): int|bool {}
 
 /**
- * @param string $file
+ * @param string $filename
  * @param int $line
  */
-function headers_sent(&$file = null, &$line = null): bool {}
+function headers_sent(&$filename = null, &$line = null): bool {}
 
 function headers_list(): array {}
 
@@ -537,9 +537,9 @@ function bin2hex(string $string): string {}
 
 function hex2bin(string $string): string|false {}
 
-function strspn(string $string, string $characters, int $start = 0, ?int $length = null): int {}
+function strspn(string $string, string $characters, int $offset = 0, ?int $length = null): int {}
 
-function strcspn(string $string, string $characters, int $start = 0, ?int $length = null): int {}
+function strcspn(string $string, string $characters, int $offset = 0, ?int $length = null): int {}
 
 #if HAVE_NL_LANGINFO
 function nl_langinfo(int $item): string|false {}
@@ -602,9 +602,9 @@ function str_ends_with(string $haystack, string $needle): bool {}
 
 function chunk_split(string $string, int $length = 76, string $separator = "\r\n"): string {}
 
-function substr(string $string, int $start, ?int $length = null): string {}
+function substr(string $string, int $offset, ?int $length = null): string {}
 
-function substr_replace(array|string $string, array|string $replace, array|int $start, array|int|null $length = null): string|array {}
+function substr_replace(array|string $string, array|string $replace, array|int $offset, array|int|null $length = null): string|array {}
 
 function quotemeta(string $string): string {}
 
@@ -616,7 +616,7 @@ function ucfirst(string $string): string {}
 
 function lcfirst(string $string): string {}
 
-function ucwords(string $string, string $delimiters = " \t\r\n\f\v"): string {}
+function ucwords(string $string, string $separators = " \t\r\n\f\v"): string {}
 
 function strtr(string $string, string|array $from, ?string $to = null): string {}
 
@@ -654,7 +654,7 @@ function setlocale(int $category, $locales, ...$rest): string|false {}
 /** @param array $result */
 function parse_str(string $string, &$result): void {}
 
-function str_getcsv(string $string, string $delimiter = ",", string $enclosure = "\"", string $escape = '\\'): array {}
+function str_getcsv(string $string, string $separator = ",", string $enclosure = "\"", string $escape = '\\'): array {}
 
 function str_repeat(string $string, int $times): string {}
 
@@ -682,7 +682,7 @@ function str_split(string $string, int $length = 1): array {}
 
 function strpbrk(string $string, string $characters): string|false {}
 
-function substr_compare(string $main_string, string $string, int $offset, ?int $length = null, bool $case_insensitive = false): int {}
+function substr_compare(string $haystack, string $needle, int $offset, ?int $length = null, bool $case_insensitive = false): int {}
 
 function utf8_encode(string $string): string {}
 
@@ -856,10 +856,10 @@ function unlink(string $filename, $context = null): bool {}
 function file_put_contents(string $filename, mixed $content, int $flags = 0, $context = null): int|false {}
 
 /** @param resource $stream */
-function fputcsv($stream, array $fields, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): int|false {}
+function fputcsv($stream, array $fields, string $separator = ",", string $enclosure = "\"", string $escape = "\\"): int|false {}
 
 /** @param resource $stream */
-function fgetcsv($stream, ?int $length = null, string $delimiter = ",", string $enclosure = "\"", string $escape = "\\"): array|false {}
+function fgetcsv($stream, ?int $length = null, string $separator = ",", string $enclosure = "\"", string $escape = "\\"): array|false {}
 
 function realpath(string $path): string|false {}
 
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index 5f766ad54fc97..f707951963a3b 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 4eeaf5c6c4a570c38577fc8d0047e2437f542074 */
+ * Stub hash: 2c2e3c377e2c3716845541b7832061e292b5aaf6 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -70,7 +70,7 @@ ZEND_END_ARG_INFO()
 #define arginfo_stream_wrapper_restore arginfo_stream_wrapper_unregister
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_push, 0, 1, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(1, stack, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
 	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
@@ -132,16 +132,16 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_key, 0, 1, MAY_BE_LONG|MAY_BE_ST
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_min, 0, 1, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, arg, IS_MIXED, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(0, args, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
+	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_max arginfo_min
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_walk, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_MASK(1, input, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
+	ZEND_ARG_TYPE_MASK(1, array, MAY_BE_ARRAY|MAY_BE_OBJECT, NULL)
 	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
-	ZEND_ARG_TYPE_INFO(0, argument, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, arg, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_array_walk_recursive arginfo_array_walk
@@ -171,7 +171,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_fill, 0, 3, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, start, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, length, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
@@ -194,10 +194,7 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_array_shift arginfo_array_pop
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_unshift, 0, 1, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
-	ZEND_ARG_VARIADIC_TYPE_INFO(0, values, IS_MIXED, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_array_unshift arginfo_array_push
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_splice, 0, 2, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(1, array, IS_ARRAY, 0)
@@ -336,7 +333,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_filter, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, array, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, callback, IS_CALLABLE, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_keys, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_map, 0, 2, IS_ARRAY, 0)
@@ -377,11 +374,11 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_constant, 0, 1, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_ip2long, 0, 1, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, ip_address, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, ip, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_long2ip, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, ip_address, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, ip, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getenv, 0, 0, MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_FALSE)
@@ -391,12 +388,12 @@ ZEND_END_ARG_INFO()
 
 #if defined(HAVE_PUTENV)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_putenv, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, setting, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, assignment, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_getopt, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, options, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, short_options, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, long_options, IS_ARRAY, 0, "[]")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, rest_index, "null")
 ZEND_END_ARG_INFO()
@@ -436,7 +433,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_error_log, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, message_type, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, destination, IS_STRING, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, extra_headers, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, additional_headers, IS_STRING, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_error_get_last, 0, 0, IS_ARRAY, 1)
@@ -554,12 +551,12 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_unregister_tick_function, 0, 1,
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_is_uploaded_file, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_move_uploaded_file, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, new_path, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, new_filename, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_parse_ini_file, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
@@ -611,7 +608,7 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_gethostbyaddr, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, ip_address, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, ip, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_gethostbyname, 0, 1, IS_STRING, 0)
@@ -718,13 +715,13 @@ ZEND_END_ARG_INFO()
 
 #if defined(HAVE_INET_NTOP)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_inet_ntop, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, ip_address, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, ip, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
 #if defined(HAVE_INET_PTON)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_inet_pton, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, ip_address, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, ip, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 #endif
 
@@ -736,7 +733,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_header, 0, 1, IS_VOID, 0)
 	ZEND_ARG_TYPE_INFO(0, header, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, replace, _IS_BOOL, 0, "true")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, http_response_code, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, response_code, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_header_remove, 0, 0, IS_VOID, 0)
@@ -760,7 +757,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_http_response_code, 0, 0, MAY_BE
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_headers_sent, 0, 0, _IS_BOOL, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, file, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, filename, "null")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, line, "null")
 ZEND_END_ARG_INFO()
 
@@ -811,7 +808,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strspn, 0, 2, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, characters, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, start, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
@@ -927,14 +924,14 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr, 0, 2, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, start, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_substr_replace, 0, 3, MAY_BE_STRING|MAY_BE_ARRAY)
 	ZEND_ARG_TYPE_MASK(0, string, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
 	ZEND_ARG_TYPE_MASK(0, replace, MAY_BE_ARRAY|MAY_BE_STRING, NULL)
-	ZEND_ARG_TYPE_MASK(0, start, MAY_BE_ARRAY|MAY_BE_LONG, NULL)
+	ZEND_ARG_TYPE_MASK(0, offset, MAY_BE_ARRAY|MAY_BE_LONG, NULL)
 	ZEND_ARG_TYPE_MASK(0, length, MAY_BE_ARRAY|MAY_BE_LONG|MAY_BE_NULL, "null")
 ZEND_END_ARG_INFO()
 
@@ -954,7 +951,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ucwords, 0, 1, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiters, IS_STRING, 0, "\" \\t\\r\\n\\f\\v\"")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, separators, IS_STRING, 0, "\" \\t\\r\\n\\f\\v\"")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_strtr, 0, 2, IS_STRING, 0)
@@ -1019,7 +1016,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_str_getcsv, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiter, IS_STRING, 0, "\",\"")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, separator, IS_STRING, 0, "\",\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enclosure, IS_STRING, 0, "\"\\\"\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, escape, IS_STRING, 0, "\'\\\\\'")
 ZEND_END_ARG_INFO()
@@ -1081,8 +1078,8 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_strpbrk, 0, 2, MAY_BE_STRING|MAY
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_substr_compare, 0, 3, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, main_string, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, haystack, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, needle, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, offset, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, case_insensitive, _IS_BOOL, 0, "false")
@@ -1332,7 +1329,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fputcsv, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
 	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO(0, fields, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiter, IS_STRING, 0, "\",\"")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, separator, IS_STRING, 0, "\",\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enclosure, IS_STRING, 0, "\"\\\"\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, escape, IS_STRING, 0, "\"\\\\\"")
 ZEND_END_ARG_INFO()
@@ -1340,7 +1337,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_fgetcsv, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_INFO(0, stream)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, length, IS_LONG, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, delimiter, IS_STRING, 0, "\",\"")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, separator, IS_STRING, 0, "\",\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, enclosure, IS_STRING, 0, "\"\\\"\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, escape, IS_STRING, 0, "\"\\\\\"")
 ZEND_END_ARG_INFO()
@@ -1381,23 +1378,21 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_filetype, 0, 1, MAY_BE_STRING|MA
 	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_file_exists, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
-ZEND_END_ARG_INFO()
+#define arginfo_file_exists arginfo_is_uploaded_file
 
-#define arginfo_is_writable arginfo_file_exists
+#define arginfo_is_writable arginfo_is_uploaded_file
 
-#define arginfo_is_writeable arginfo_file_exists
+#define arginfo_is_writeable arginfo_is_uploaded_file
 
-#define arginfo_is_readable arginfo_file_exists
+#define arginfo_is_readable arginfo_is_uploaded_file
 
-#define arginfo_is_executable arginfo_file_exists
+#define arginfo_is_executable arginfo_is_uploaded_file
 
-#define arginfo_is_file arginfo_file_exists
+#define arginfo_is_file arginfo_is_uploaded_file
 
-#define arginfo_is_dir arginfo_file_exists
+#define arginfo_is_dir arginfo_is_uploaded_file
 
-#define arginfo_is_link arginfo_file_exists
+#define arginfo_is_link arginfo_is_uploaded_file
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stat, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)

From 43f6f01d14f30de7ae501b61137e8ece08fea842 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 12:10:37 +0200
Subject: [PATCH 03/10] Some updates

---
 ext/standard/basic_functions.stub.php  | 94 +++++++++++++-------------
 ext/standard/basic_functions_arginfo.h | 50 +++++++-------
 2 files changed, 73 insertions(+), 71 deletions(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index a25d5fb425677..94751d66c2010 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -688,6 +688,8 @@ function utf8_encode(string $string): string {}
 
 function utf8_decode(string $string): string {}
 
+/* dir.c */
+
 /**
  * @param resource|null $context
  * @return resource|false
@@ -958,18 +960,18 @@ function vfprintf($stream, string $format, array $values): int {}
 /* fsock.c */
 
 /**
- * @param int $errno
+ * @param int $error_code
  * @param string $error_message
  * @return resource|false
  */
-function fsockopen(string $hostname, int $port = -1, &$errno = null, &$error_message = null, ?float $timeout = null) {}
+function fsockopen(string $hostname, int $port = -1, &$error_code = null, &$error_message = null, ?float $timeout = null) {}
 
 /**
- * @param int $errno
+ * @param int $error_code
  * @param string $error_message
  * @return resource|false
  */
-function pfsockopen(string $hostname, int $port = -1, &$errno = null, &$error_message = null, ?float $timeout = null) {}
+function pfsockopen(string $hostname, int $port = -1, &$error_code = null, &$error_message = null, ?float $timeout = null) {}
 
 /* http.c */
 
@@ -1031,69 +1033,69 @@ function mail(string $to, string $subject, string $message, array|string $additi
 
 /* math.c */
 
-function abs(int|float $number): int|float {}
+function abs(int|float $num): int|float {}
 
-function ceil(int|float $number): float {}
+function ceil(int|float $num): float {}
 
-function floor(int|float $number): float {}
+function floor(int|float $num): float {}
 
-function round(int|float $number, int $precision = 0, int $mode = PHP_ROUND_HALF_UP): float {}
+function round(int|float $num, int $precision = 0, int $mode = PHP_ROUND_HALF_UP): float {}
 
-function sin(float $number): float {}
+function sin(float $num): float {}
 
-function cos(float $number): float {}
+function cos(float $num): float {}
 
-function tan(float $number): float {}
+function tan(float $num): float {}
 
-function asin(float $number): float {}
+function asin(float $num): float {}
 
-function acos(float $number): float {}
+function acos(float $num): float {}
 
-function atan(float $number): float {}
+function atan(float $num): float {}
 
-function atanh(float $number): float {}
+function atanh(float $num): float {}
 
 function atan2(float $y, float $x): float {}
 
-function sinh(float $number): float {}
+function sinh(float $num): float {}
 
-function cosh(float $number): float {}
+function cosh(float $num): float {}
 
-function tanh(float $number): float {}
+function tanh(float $num): float {}
 
-function asinh(float $number): float {}
+function asinh(float $num): float {}
 
-function acosh(float $number): float {}
+function acosh(float $num): float {}
 
-function expm1(float $number): float {}
+function expm1(float $num): float {}
 
-function log1p(float $number): float {}
+function log1p(float $num): float {}
 
 function pi(): float {}
 
-function is_finite(float $number): bool {}
+function is_finite(float $num): bool {}
 
-function is_nan(float $number): bool {}
+function is_nan(float $num): bool {}
 
-function intdiv(int $dividend, int $divisor): int {}
+function intdiv(int $num1, int $num2): int {}
 
-function is_infinite(float $number): bool {}
+function is_infinite(float $num): bool {}
 
-function pow(mixed $base, mixed $exp): int|float|object {}
+function pow(mixed $num, mixed $exponent): int|float|object {}
 
-function exp(float $number): float {}
+function exp(float $num): float {}
 
-function log(float $number, float $base = M_E): float {}
+function log(float $num, float $base = M_E): float {}
 
-function log10(float $number): float {}
+function log10(float $num): float {}
 
-function sqrt(float $number): float {}
+function sqrt(float $num): float {}
 
 function hypot(float $x, float $y): float {}
 
-function deg2rad(float $number): float {}
+function deg2rad(float $num): float {}
 
-function rad2deg(float $number): float {}
+function rad2deg(float $num): float {}
 
 function bindec(string $binary_string): int|float {}
 
@@ -1101,19 +1103,19 @@ function hexdec(string $hex_string): int|float {}
 
 function octdec(string $octal_string): int|float {}
 
-function decbin(int $number): string {}
+function decbin(int $num): string {}
 
-function decoct(int $number): string {}
+function decoct(int $num): string {}
 
-function dechex(int $number): string {}
+function dechex(int $num): string {}
 
-function base_convert(string $number, int $from_base, int $to_base): string {}
+function base_convert(string $num, int $from_base, int $to_base): string {}
 
-function number_format(float $number, int $decimals = 0, ?string $decimal_point = "." , ?string $thousands_separator = ","): string {}
+function number_format(float $num, int $decimals = 0, ?string $decimal_separator = "." , ?string $thousands_separator = ","): string {}
 
-function fmod(float $x, float $y): float {}
+function fmod(float $num1, float $num2): float {}
 
-function fdiv(float $dividend, float $divisor): float {}
+function fdiv(float $num1, float $num2): float {}
 
 /* microtime.c */
 
@@ -1152,7 +1154,7 @@ function password_algos(): array {}
  * @param array $pipes
  * @return resource|false
  */
-function proc_open(array|string $command, array $descriptor_spec, &$pipes, ?string $cwd = null, ?array $env = null, ?array $options = null) {}
+function proc_open(array|string $command, array $descriptor_spec, &$pipes, ?string $cwd = null, ?array $env_vars = null, ?array $options = null) {}
 
 /** @param resource $process */
 function proc_close($process): int {}
@@ -1198,7 +1200,7 @@ function soundex(string $string): string {}
 
 /* streamsfuncs.c */
 
-function stream_select(?array &$read, ?array &$write, ?array &$except, ?int $seconds, int $microsectons = 0): int|false {}
+function stream_select(?array &$read, ?array &$write, ?array &$except, ?int $seconds, int $microseconds = 0): int|false {}
 
 /** @return resource */
 function stream_context_create(?array $options = null, ?array $params = null) {}
@@ -1237,20 +1239,20 @@ function stream_filter_append($stream, string $filter_name, int $mode = 0, mixed
 function stream_filter_remove($stream_filter): bool {}
 
 /**
- * @param int $errno
+ * @param int $error_code
  * @param string $error_message
  * @param resource|null $context
  * @return resource|false
  */
-function stream_socket_client(string $address, &$errno = null, &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null) {}
+function stream_socket_client(string $address, &$error_code = null, &$error_message = null, ?float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null) {}
 
 /**
- * @param int $errno
+ * @param int $error_code
  * @param string $error_message
  * @param resource|null $context
  * @return resource|false
  */
-function stream_socket_server(string $address, &$errno = null, &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null) {}
+function stream_socket_server(string $address, &$error_code = null, &$error_message = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null) {}
 
 /**
  * @param resource $socket
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index f707951963a3b..d78d57c0639dd 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 2c2e3c377e2c3716845541b7832061e292b5aaf6 */
+ * Stub hash: 6a0d8ead5c3b4a9ced8731089e48c623c0b653a3 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -1489,7 +1489,7 @@ ZEND_END_ARG_INFO()
 ZEND_BEGIN_ARG_INFO_EX(arginfo_fsockopen, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, hostname, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, port, IS_LONG, 0, "-1")
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_code, "null")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, timeout, IS_DOUBLE, 1, "null")
 ZEND_END_ARG_INFO()
@@ -1594,23 +1594,23 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_mail, 0, 3, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_abs, 0, 1, MAY_BE_LONG|MAY_BE_DOUBLE)
-	ZEND_ARG_TYPE_MASK(0, number, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
+	ZEND_ARG_TYPE_MASK(0, num, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_ceil, 0, 1, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_MASK(0, number, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
+	ZEND_ARG_TYPE_MASK(0, num, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
 ZEND_END_ARG_INFO()
 
 #define arginfo_floor arginfo_ceil
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_round, 0, 1, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_MASK(0, number, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
+	ZEND_ARG_TYPE_MASK(0, num, MAY_BE_LONG|MAY_BE_DOUBLE, NULL)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, precision, IS_LONG, 0, "0")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, mode, IS_LONG, 0, "PHP_ROUND_HALF_UP")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_sin, 0, 1, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_cos arginfo_sin
@@ -1647,27 +1647,27 @@ ZEND_END_ARG_INFO()
 #define arginfo_pi arginfo_lcg_value
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_is_finite, 0, 1, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_is_nan arginfo_is_finite
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_intdiv, 0, 2, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, dividend, IS_LONG, 0)
-	ZEND_ARG_TYPE_INFO(0, divisor, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, num1, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, num2, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_is_infinite arginfo_is_finite
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_pow, 0, 2, MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_OBJECT)
-	ZEND_ARG_TYPE_INFO(0, base, IS_MIXED, 0)
-	ZEND_ARG_TYPE_INFO(0, exp, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_MIXED, 0)
+	ZEND_ARG_TYPE_INFO(0, exponent, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_exp arginfo_sin
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_log, 0, 1, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_DOUBLE, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, base, IS_DOUBLE, 0, "M_E")
 ZEND_END_ARG_INFO()
 
@@ -1697,7 +1697,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_octdec, 0, 1, MAY_BE_LONG|MAY_BE
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_decbin, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 #define arginfo_decoct arginfo_decbin
@@ -1705,25 +1705,25 @@ ZEND_END_ARG_INFO()
 #define arginfo_dechex arginfo_decbin
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_base_convert, 0, 3, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_STRING, 0)
 	ZEND_ARG_TYPE_INFO(0, from_base, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, to_base, IS_LONG, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_number_format, 0, 1, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, number, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num, IS_DOUBLE, 0)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, decimals, IS_LONG, 0, "0")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, decimal_point, IS_STRING, 1, "\".\"")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, decimal_separator, IS_STRING, 1, "\".\"")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, thousands_separator, IS_STRING, 1, "\",\"")
 ZEND_END_ARG_INFO()
 
-#define arginfo_fmod arginfo_hypot
-
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_fdiv, 0, 2, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_INFO(0, dividend, IS_DOUBLE, 0)
-	ZEND_ARG_TYPE_INFO(0, divisor, IS_DOUBLE, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_fmod, 0, 2, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num1, IS_DOUBLE, 0)
+	ZEND_ARG_TYPE_INFO(0, num2, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
 
+#define arginfo_fdiv arginfo_fmod
+
 #if defined(HAVE_GETTIMEOFDAY)
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_microtime, 0, 0, MAY_BE_STRING|MAY_BE_DOUBLE)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, as_float, _IS_BOOL, 0, "false")
@@ -1779,7 +1779,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_proc_open, 0, 0, 3)
 	ZEND_ARG_TYPE_INFO(0, descriptor_spec, IS_ARRAY, 0)
 	ZEND_ARG_INFO(1, pipes)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cwd, IS_STRING, 1, "null")
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, env, IS_ARRAY, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, env_vars, IS_ARRAY, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 1, "null")
 ZEND_END_ARG_INFO()
 #endif
@@ -1841,7 +1841,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_select, 0, 4, MAY_BE_LONG
 	ZEND_ARG_TYPE_INFO(1, write, IS_ARRAY, 1)
 	ZEND_ARG_TYPE_INFO(1, except, IS_ARRAY, 1)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 1)
-	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, microsectons, IS_LONG, 0, "0")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, microseconds, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_context_create, 0, 0, 0)
@@ -1892,7 +1892,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_socket_client, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_code, "null")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, timeout, IS_DOUBLE, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "STREAM_CLIENT_CONNECT")
@@ -1901,7 +1901,7 @@ ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_stream_socket_server, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, address, IS_STRING, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, errno, "null")
+	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_code, "null")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(1, error_message, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "STREAM_SERVER_BIND | STREAM_SERVER_LISTEN")
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")

From d4633aaad36ae752bd37a90d13c57de88ae9b555 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 12:15:00 +0200
Subject: [PATCH 04/10] Consistently use $from/$to

---
 ext/standard/basic_functions.stub.php | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index 94751d66c2010..652f2dd6e87f0 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -357,7 +357,7 @@ function unregister_tick_function(callable $callback): void {}
 
 function is_uploaded_file(string $filename): bool {}
 
-function move_uploaded_file(string $filename, string $new_filename): bool {}
+function move_uploaded_file(string $from, string $to): bool {}
 
 function parse_ini_file(string $filename, bool $process_sections = false, int $scanner_mode = INI_SCANNER_NORMAL): array|false {}
 
@@ -835,10 +835,10 @@ function fputs($stream, string $string, ?int $max_length = null): int|false {}
 function mkdir(string $directory, int $mode = 0777, bool $recursive = false, $context = null): bool {}
 
 /** @param resource|null $context */
-function rename(string $old_name, string $new_name, $context = null): bool {}
+function rename(string $from, string $to, $context = null): bool {}
 
 /** @param resource|null $context */
-function copy(string $source, string $dest, $context = null): bool {}
+function copy(string $from, string $to, $context = null): bool {}
 
 function tempnam(string $directory, string $prefix): string|false {}
 
@@ -1290,10 +1290,10 @@ function stream_socket_pair(int $domain, int $type, int $protocol): array|false
 #endif
 
 /**
- * @param resource $source
- * @param resource $dest
+ * @param resource $from
+ * @param resource $to
  */
-function stream_copy_to_stream($source, $dest, ?int $max_length = null, int $offset = 0): int|false {}
+function stream_copy_to_stream($from, $to, ?int $max_length = null, int $offset = 0): int|false {}
 
 /** @param resource $stream */
 function stream_get_contents($stream, ?int $max_length = null, int $offset = -1): string|false {}

From 846306ed0ceafbdcd8525cf4ca2eb5ff1bfd70c1 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 12:18:57 +0200
Subject: [PATCH 05/10] Use $start_index in array_fill()

Go back to what the manual calls is ... it seems clearest.
---
 ext/standard/basic_functions.stub.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index 652f2dd6e87f0..75876ceab651c 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -121,7 +121,7 @@ function extract(array &$array, int $flags = EXTR_OVERWRITE, string $prefix = ""
  */
 function compact($var_name, ...$var_names): array {}
 
-function array_fill(int $start, int $count, mixed $value): array {}
+function array_fill(int $start_index, int $count, mixed $value): array {}
 
 function array_fill_keys(array $keys, mixed $value): array {}
 

From 5a15629f6384410f6ca262e4726fcbf00a11da4b Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 12:20:37 +0200
Subject: [PATCH 06/10] Start on test updates

---
 Zend/tests/bug75290.phpt                      |    2 +-
 Zend/tests/bug79783.phpt                      |    2 +-
 Zend/tests/bug79979.phpt                      |   12 +-
 Zend/tests/call_user_func_001.phpt            |    4 +-
 ext/standard/basic_functions_arginfo.h        |   22 +-
 ext/standard/tests/array/array_chunk2.phpt    |    4 +-
 .../tests/array/array_chunk_variation5.phpt   |   12 +-
 .../array/array_multisort_variation1.phpt     |   50 +-
 .../tests/array/array_next_error2.phpt        |    2 +-
 ext/standard/tests/array/array_pad.phpt       |    2 +-
 ext/standard/tests/array/array_rand.phpt      |    6 +-
 .../tests/array/array_rand_variation5.phpt    |    8 +-
 .../tests/array/array_walk_objects.phpt       |    2 +-
 .../tests/array/array_walk_rec_objects.phpt   |  Bin 921 -> 921 bytes
 ext/standard/tests/array/extract_error.phpt   |    4 +-
 ext/standard/tests/array/max.phpt             |    6 +-
 ext/standard/tests/array/min.phpt             |    6 +-
 ext/standard/tests/array/prev_error3.phpt     |    2 +-
 ext/standard/tests/array/sizeof_object2.phpt  |   20 +-
 .../tests/assert/assert_options_error.phpt    |    2 +-
 .../tests/file/fgetcsv_error_conditions.phpt  |    4 +-
 .../tests/file/fgetcsv_variation12.phpt       |  144 +-
 .../tests/file/fgetcsv_variation19.phpt       |  150 +-
 .../tests/file/file_get_contents_error.phpt   |    2 +-
 .../file/file_get_contents_error002.phpt      |    2 +-
 ..._get_contents_file_put_contents_error.phpt |    2 +-
 .../tests/file/fputcsv_variation2.phpt        |  216 +-
 .../tests/file/fputcsv_variation4.phpt        |  216 +-
 .../tests/file/fputcsv_variation9.phpt        |  216 +-
 .../tests/file/mkdir_rmdir_variation2.phpt    |    4 +-
 .../tests/file/tempnam_variation7.phpt        |    4 +-
 ext/standard/tests/file/touch.phpt            |    2 +-
 ext/standard/tests/file/userstreams.phpt      |    2 +-
 ext/standard/tests/filters/001.phpt           |    6 +-
 ext/standard/tests/general_functions/010.phpt |    2 +-
 .../tests/general_functions/bug32647.phpt     |   16 +-
 .../general_functions/proc_open_array.phpt    |    2 +-
 .../general_functions/proc_open_pipes3.phpt   |    2 +-
 .../tests/general_functions/putenv.phpt       |    4 +-
 .../register_tick_function_error.phpt         |    2 +-
 ext/standard/tests/image/bug79877.phpt        |    2 +-
 ext/standard/tests/math/abs_variation.phpt    |   16 +-
 .../tests/math/base_convert_error.phpt        |    6 +-
 .../tests/math/base_convert_variation1.phpt   |    4 +-
 ext/standard/tests/math/ceil_variation1.phpt  |   16 +-
 ext/standard/tests/math/decbin_basic.phpt     |    2 +-
 .../tests/math/decbin_basiclong_64bit.phpt    |    2 +-
 .../tests/math/decbin_variation1_64bit.phpt   |   20 +-
 ext/standard/tests/math/dechex_basic.phpt     |    2 +-
 .../tests/math/dechex_basiclong_64bit.phpt    |    2 +-
 .../tests/math/dechex_variation1_64bit.phpt   |   20 +-
 ext/standard/tests/math/decoct_basic.phpt     |    2 +-
 .../tests/math/decoct_basiclong_64bit.phpt    |    2 +-
 .../tests/math/decoct_variation1_64bit.phpt   |   20 +-
 ext/standard/tests/math/floor_variation1.phpt |   16 +-
 ext/standard/tests/math/round_variation1.phpt |   16 +-
 .../stream_get_contents_negative_length.phpt  |    4 +-
 .../tests/strings/addcslashes_001.phpt        |  Bin 1641 -> 1643 bytes
 ext/standard/tests/strings/bug40754.phpt      |    4 +-
 ext/standard/tests/strings/bug61116.phpt      |    4 +-
 .../tests/strings/chunk_split_variation5.phpt |  Bin 2094 -> 2086 bytes
 .../tests/strings/chunk_split_variation8.phpt |    8 +-
 ext/standard/tests/strings/implode1.phpt      |  Bin 6041 -> 6048 bytes
 .../tests/strings/join_variation1.phpt        |   12 +-
 .../tests/strings/join_variation2.phpt        |   38 +-
 .../tests/strings/join_variation4.phpt        |  Bin 2102 -> 2107 bytes
 .../tests/strings/join_variation5.phpt        |    2 +-
 .../strings/levenshtein_error_conditions.phpt |    4 +-
 ext/standard/tests/strings/metaphone.phpt     |    2 +-
 .../tests/strings/str_pad_variation1.phpt     |    2 +-
 ext/standard/tests/strings/str_repeat.phpt    |  Bin 2809 -> 2810 bytes
 ext/standard/tests/strings/strcspn.phpt       |    2 +-
 .../tests/strings/strcspn_variation11.phpt    |  916 ++--
 .../tests/strings/strcspn_variation12.phpt    | 3436 +++++++-------
 .../tests/strings/strip_tags_variation2.phpt  |    2 +-
 ext/standard/tests/strings/strpbrk_error.phpt |    2 +-
 .../tests/strings/strspn_variation11.phpt     |  916 ++--
 .../tests/strings/strspn_variation12.phpt     | 3974 ++++++++---------
 .../tests/strings/substr_replace_error.phpt   |    2 +-
 .../tests/strings/vfprintf_error3.phpt        |    2 +-
 .../tests/strings/vfprintf_error4.phpt        |    2 +-
 .../tests/strings/vfprintf_variation1.phpt    |    2 +-
 .../tests/strings/vprintf_variation2.phpt     |   46 +-
 .../tests/strings/wordwrap_error.phpt         |    2 +-
 84 files changed, 5347 insertions(+), 5351 deletions(-)

diff --git a/Zend/tests/bug75290.phpt b/Zend/tests/bug75290.phpt
index 3b28e621d2c4c..9d9d1a05619c1 100644
--- a/Zend/tests/bug75290.phpt
+++ b/Zend/tests/bug75290.phpt
@@ -12,7 +12,7 @@ var_dump(function ($someThing) {});
 object(Closure)#2 (1) {
   ["parameter"]=>
   array(1) {
-    ["$number"]=>
+    ["$num"]=>
     string(10) "<required>"
   }
 }
diff --git a/Zend/tests/bug79783.phpt b/Zend/tests/bug79783.phpt
index 74d2672e02a00..6accb0c284de9 100644
--- a/Zend/tests/bug79783.phpt
+++ b/Zend/tests/bug79783.phpt
@@ -5,7 +5,7 @@ Bug #79783: Segfault in php_str_replace_common
 str_replace("a", "b", "c", strlen("d"));
 ?>
 --EXPECTF--
-Fatal error: Uncaught Error: str_replace(): Argument #4 ($replace_count) cannot be passed by reference in %s:%d
+Fatal error: Uncaught Error: str_replace(): Argument #4 ($count) cannot be passed by reference in %s:%d
 Stack trace:
 #0 {main}
   thrown in %s on line %d
diff --git a/Zend/tests/bug79979.phpt b/Zend/tests/bug79979.phpt
index d655a0edce577..753b2abdb5f77 100644
--- a/Zend/tests/bug79979.phpt
+++ b/Zend/tests/bug79979.phpt
@@ -6,17 +6,17 @@ Bug #79979 (passing value to by-ref param via CUF(A) crashes)
 namespace Foo;
 
 call_user_func_array("str_replace", ["a", "b", "c", new \stdClass]);
-call_user_func_array("str_replace", ["a", "b", "c", "replace_count" => new \stdClass]);
+call_user_func_array("str_replace", ["a", "b", "c", "count" => new \stdClass]);
 
 \call_user_func_array("str_replace", ["a", "b", "c", new \stdClass]);
-\call_user_func_array("str_replace", ["a", "b", "c", "replace_count" => new \stdClass]);
+\call_user_func_array("str_replace", ["a", "b", "c", "count" => new \stdClass]);
 
 ?>
 --EXPECTF--
-Warning: str_replace(): Argument #4 ($replace_count) must be passed by reference, value given in %s on line %d
+Warning: str_replace(): Argument #4 ($count) must be passed by reference, value given in %s on line %d
 
-Warning: str_replace(): Argument #4 ($replace_count) must be passed by reference, value given in %s on line %d
+Warning: str_replace(): Argument #4 ($count) must be passed by reference, value given in %s on line %d
 
-Warning: str_replace(): Argument #4 ($replace_count) must be passed by reference, value given in %s on line %d
+Warning: str_replace(): Argument #4 ($count) must be passed by reference, value given in %s on line %d
 
-Warning: str_replace(): Argument #4 ($replace_count) must be passed by reference, value given in %s on line %d
+Warning: str_replace(): Argument #4 ($count) must be passed by reference, value given in %s on line %d
diff --git a/Zend/tests/call_user_func_001.phpt b/Zend/tests/call_user_func_001.phpt
index 34234271b36b9..9497d305e2cda 100644
--- a/Zend/tests/call_user_func_001.phpt
+++ b/Zend/tests/call_user_func_001.phpt
@@ -37,5 +37,5 @@ namespace testing {
 ?>
 --EXPECT--
 string(6) "foobar"
-call_user_func(): Argument #1 ($function) must be a valid callback, cannot access private method testing\foo::priv()
-call_user_func(): Argument #1 ($function) must be a valid callback, cannot access protected method testing\foo::prot()
+call_user_func(): Argument #1 ($callback) must be a valid callback, cannot access private method testing\foo::priv()
+call_user_func(): Argument #1 ($callback) must be a valid callback, cannot access protected method testing\foo::prot()
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index d78d57c0639dd..83e96e40a89bc 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 6a0d8ead5c3b4a9ced8731089e48c623c0b653a3 */
+ * Stub hash: 66d077cacb14825267889aa41369bd09416b5e41 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -170,7 +170,7 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_compact, 0, 1, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_array_fill, 0, 3, IS_ARRAY, 0)
-	ZEND_ARG_TYPE_INFO(0, start, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, start_index, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, count, IS_LONG, 0)
 	ZEND_ARG_TYPE_INFO(0, value, IS_MIXED, 0)
 ZEND_END_ARG_INFO()
@@ -555,8 +555,8 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_is_uploaded_file, 0, 1, _IS_BOOL
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_move_uploaded_file, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, new_filename, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, from, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, to, IS_STRING, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_parse_ini_file, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
@@ -1281,16 +1281,12 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_mkdir, 0, 1, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rename, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, old_name, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, new_name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, from, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, to, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_copy, 0, 2, _IS_BOOL, 0)
-	ZEND_ARG_TYPE_INFO(0, source, IS_STRING, 0)
-	ZEND_ARG_TYPE_INFO(0, dest, IS_STRING, 0)
-	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
-ZEND_END_ARG_INFO()
+#define arginfo_copy arginfo_rename
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_tempnam, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
 	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
@@ -1955,8 +1951,8 @@ ZEND_END_ARG_INFO()
 #endif
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_stream_copy_to_stream, 0, 2, MAY_BE_LONG|MAY_BE_FALSE)
-	ZEND_ARG_INFO(0, source)
-	ZEND_ARG_INFO(0, dest)
+	ZEND_ARG_INFO(0, from)
+	ZEND_ARG_INFO(0, to)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, max_length, IS_LONG, 1, "null")
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, offset, IS_LONG, 0, "0")
 ZEND_END_ARG_INFO()
diff --git a/ext/standard/tests/array/array_chunk2.phpt b/ext/standard/tests/array/array_chunk2.phpt
index f3846a1d7806d..c83f051a271de 100644
--- a/ext/standard/tests/array/array_chunk2.phpt
+++ b/ext/standard/tests/array/array_chunk2.phpt
@@ -24,8 +24,8 @@ var_dump(array_chunk($input_array, 10));
 var_dump(array_chunk($input_array, 10, true));
 ?>
 --EXPECT--
-array_chunk(): Argument #2 ($size) must be greater than 0
-array_chunk(): Argument #2 ($size) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
 array(5) {
   [0]=>
   array(1) {
diff --git a/ext/standard/tests/array/array_chunk_variation5.phpt b/ext/standard/tests/array/array_chunk_variation5.phpt
index 4aa4ea1172358..24123b03707a4 100644
--- a/ext/standard/tests/array/array_chunk_variation5.phpt
+++ b/ext/standard/tests/array/array_chunk_variation5.phpt
@@ -42,9 +42,9 @@ foreach ($sizes as $size){
 *** Testing array_chunk() : usage variations ***
 
 -- Testing array_chunk() when size = -1 --
-array_chunk(): Argument #2 ($size) must be greater than 0
-array_chunk(): Argument #2 ($size) must be greater than 0
-array_chunk(): Argument #2 ($size) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
 
 -- Testing array_chunk() when size = 4 --
 array(1) {
@@ -82,9 +82,9 @@ array(1) {
 }
 
 -- Testing array_chunk() when size = 0 --
-array_chunk(): Argument #2 ($size) must be greater than 0
-array_chunk(): Argument #2 ($size) must be greater than 0
-array_chunk(): Argument #2 ($size) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
+array_chunk(): Argument #2 ($length) must be greater than 0
 
 -- Testing array_chunk() when size = 1.5 --
 array(3) {
diff --git a/ext/standard/tests/array/array_multisort_variation1.phpt b/ext/standard/tests/array/array_multisort_variation1.phpt
index f93ad2cfc7df9..c6cb286231e49 100644
--- a/ext/standard/tests/array/array_multisort_variation1.phpt
+++ b/ext/standard/tests/array/array_multisort_variation1.phpt
@@ -103,76 +103,76 @@ foreach($inputs as $key =>$value) {
 *** Testing array_multisort() : usage variation ***
 
 --int 0--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag that has not already been specified
+array_multisort(): Argument #1 ($array) must be an array or a sort flag that has not already been specified
 
 --int 1--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag that has not already been specified
+array_multisort(): Argument #1 ($array) must be an array or a sort flag that has not already been specified
 
 --int 12345--
-array_multisort(): Argument #1 ($array1) must be a valid sort flag
+array_multisort(): Argument #1 ($array) must be a valid sort flag
 
 --int -12345--
-array_multisort(): Argument #1 ($array1) must be a valid sort flag
+array_multisort(): Argument #1 ($array) must be a valid sort flag
 
 --float 10.5--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --float -10.5--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --float 12.3456789000e10--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --float -12.3456789000e10--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --float .5--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --uppercase NULL--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --lowercase null--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --lowercase true--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --lowercase false--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --uppercase TRUE--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --uppercase FALSE--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --empty string DQ--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --empty string SQ--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --string DQ--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --string SQ--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --mixed case string--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --heredoc--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --instance of classWithToString--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --instance of classWithoutToString--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --undefined var--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
 
 --unset var--
-array_multisort(): Argument #1 ($array1) must be an array or a sort flag
+array_multisort(): Argument #1 ($array) must be an array or a sort flag
diff --git a/ext/standard/tests/array/array_next_error2.phpt b/ext/standard/tests/array/array_next_error2.phpt
index e9df624e0e3e4..ca4626558edda 100644
--- a/ext/standard/tests/array/array_next_error2.phpt
+++ b/ext/standard/tests/array/array_next_error2.phpt
@@ -8,7 +8,7 @@ function f() {
 var_dump(next(array(1, 2)));
 ?>
 --EXPECTF--
-Fatal error: Uncaught Error: next(): Argument #1 ($arg) cannot be passed by reference in %s:%d
+Fatal error: Uncaught Error: next(): Argument #1 ($array) cannot be passed by reference in %s:%d
 Stack trace:
 #0 {main}
   thrown in %s on line %d
diff --git a/ext/standard/tests/array/array_pad.phpt b/ext/standard/tests/array/array_pad.phpt
index 6efef020b9dfd..5abcbac87ef7d 100644
--- a/ext/standard/tests/array/array_pad.phpt
+++ b/ext/standard/tests/array/array_pad.phpt
@@ -84,4 +84,4 @@ array(4) {
   [3]=>
   float(2)
 }
-array_pad(): Argument #2 ($pad_size) must be less than or equal to 1048576
+array_pad(): Argument #2 ($length) must be less than or equal to 1048576
diff --git a/ext/standard/tests/array/array_rand.phpt b/ext/standard/tests/array/array_rand.phpt
index 52890dcafd2c5..03fb91eb53062 100644
--- a/ext/standard/tests/array/array_rand.phpt
+++ b/ext/standard/tests/array/array_rand.phpt
@@ -40,9 +40,9 @@ var_dump(array_rand(array(1,2,3), 2));
 --EXPECTF--
 array_rand(): Argument #1 ($array) cannot be empty
 array_rand(): Argument #1 ($array) cannot be empty
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
 array(3) {
   [0]=>
   int(%d)
diff --git a/ext/standard/tests/array/array_rand_variation5.phpt b/ext/standard/tests/array/array_rand_variation5.phpt
index 8b877c8a9108c..4a4295c615391 100644
--- a/ext/standard/tests/array/array_rand_variation5.phpt
+++ b/ext/standard/tests/array/array_rand_variation5.phpt
@@ -65,13 +65,13 @@ int(%d)
 int(%d)
 
 -- With num_req = 0 --
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
 
 -- With num_req = -1 --
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
 
 -- With num_req = -2 --
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
 
 -- With num_req more than number of members in 'input' array --
-array_rand(): Argument #2 ($num_req) must be between 1 and the number of elements in argument #1 ($array)
+array_rand(): Argument #2 ($num) must be between 1 and the number of elements in argument #1 ($array)
diff --git a/ext/standard/tests/array/array_walk_objects.phpt b/ext/standard/tests/array/array_walk_objects.phpt
index 2c95b5a6d0a9d..44b5b27e51e84 100644
--- a/ext/standard/tests/array/array_walk_objects.phpt
+++ b/ext/standard/tests/array/array_walk_objects.phpt
@@ -43,5 +43,5 @@ string(10) "%r\0%r*%r\0%rvar_pro"
 string(14) "test_protected"
 string(7) "var_pub"
 string(11) "test_public"
-array_walk(): Argument #1 ($input) must be of type array, string given
+array_walk(): Argument #1 ($array) must be of type array, string given
 Done
diff --git a/ext/standard/tests/array/array_walk_rec_objects.phpt b/ext/standard/tests/array/array_walk_rec_objects.phpt
index 4577e1af0c62c2a0743100a524d3d67a169395aa..a3513437a28e293e758a24a8a4ad6db41c953f05 100644
GIT binary patch
delta 17
YcmbQqK9hYzCNpbdQBh*$<UD3=05r1&umAu6

delta 17
YcmbQqK9hYzCNpbhUO{Qe<UD3=05vQH!2kdN

diff --git a/ext/standard/tests/array/extract_error.phpt b/ext/standard/tests/array/extract_error.phpt
index e5b057222ff0f..f2b0cfa69c7e9 100644
--- a/ext/standard/tests/array/extract_error.phpt
+++ b/ext/standard/tests/array/extract_error.phpt
@@ -31,6 +31,6 @@ try {
 ?>
 --EXPECT--
 *** Testing Error Conditions ***
-extract(): Argument #2 ($extract_type) must be a valid extract type
-extract(): Argument #2 ($extract_type) must be a valid extract type
+extract(): Argument #2 ($flags) must be a valid extract type
+extract(): Argument #2 ($flags) must be a valid extract type
 extract(): Argument #3 ($prefix) is required when using this extract type
diff --git a/ext/standard/tests/array/max.phpt b/ext/standard/tests/array/max.phpt
index 4360b915256d3..065461001690c 100644
--- a/ext/standard/tests/array/max.phpt
+++ b/ext/standard/tests/array/max.phpt
@@ -33,9 +33,9 @@ var_dump(max(0, true, false, true));
 
 ?>
 --EXPECT--
-max(): Argument #1 ($arg) must be of type array, int given
-max(): Argument #1 ($arg) must contain at least one element
-max(): Argument #1 ($arg) must be of type array, stdClass given
+max(): Argument #1 ($value) must be of type array, int given
+max(): Argument #1 ($value) must contain at least one element
+max(): Argument #1 ($value) must be of type array, stdClass given
 int(2)
 float(2.11)
 string(1) "t"
diff --git a/ext/standard/tests/array/min.phpt b/ext/standard/tests/array/min.phpt
index ad32ae4226924..97be4ad6828e0 100644
--- a/ext/standard/tests/array/min.phpt
+++ b/ext/standard/tests/array/min.phpt
@@ -33,9 +33,9 @@ var_dump(min(0, true, false, true));
 
 ?>
 --EXPECT--
-min(): Argument #1 ($arg) must be of type array, int given
-min(): Argument #1 ($arg) must contain at least one element
-min(): Argument #1 ($arg) must be of type array, stdClass given
+min(): Argument #1 ($value) must be of type array, int given
+min(): Argument #1 ($value) must contain at least one element
+min(): Argument #1 ($value) must be of type array, stdClass given
 int(1)
 float(2.09)
 string(0) ""
diff --git a/ext/standard/tests/array/prev_error3.phpt b/ext/standard/tests/array/prev_error3.phpt
index 7777527f16ab4..f7444975946cc 100644
--- a/ext/standard/tests/array/prev_error3.phpt
+++ b/ext/standard/tests/array/prev_error3.phpt
@@ -10,7 +10,7 @@ prev - ensure we cannot pass a temporary
 var_dump(prev(array(1, 2)));
 ?>
 --EXPECTF--
-Fatal error: Uncaught Error: prev(): Argument #1 ($arg) cannot be passed by reference in %s:%d
+Fatal error: Uncaught Error: prev(): Argument #1 ($array) cannot be passed by reference in %s:%d
 Stack trace:
 #0 {main}
   thrown in %s on line %d
diff --git a/ext/standard/tests/array/sizeof_object2.phpt b/ext/standard/tests/array/sizeof_object2.phpt
index 754198765685f..7f165bc5a893a 100644
--- a/ext/standard/tests/array/sizeof_object2.phpt
+++ b/ext/standard/tests/array/sizeof_object2.phpt
@@ -104,22 +104,22 @@ echo "Done";
 --- Testing sizeof() with objects which doesn't implement Countable interface ---
 -- Iteration 1 --
 Default Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test given
-COUNT_NORMAL Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test given
-COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test given
 -- Iteration 2 --
 Default Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test1 given
-COUNT_NORMAL Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test1 given
-COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test1 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test1 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test1 given
 -- Iteration 3 --
 Default Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test2 given
-COUNT_NORMAL Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test2 given
-COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, test2 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test2 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, test2 given
 -- Iteration 4 --
 Default Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, child_test2 given
-COUNT_NORMAL Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, child_test2 given
-COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, child_test2 given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, child_test2 given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, child_test2 given
 -- Iteration 5 --
 Default Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, concrete_class given
-COUNT_NORMAL Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, concrete_class given
-COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($var) must be of type Countable|array, concrete_class given
+COUNT_NORMAL Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, concrete_class given
+COUNT_RECURSIVE Mode: sizeof(): Argument #1 ($value) must be of type Countable|array, concrete_class given
 Done
diff --git a/ext/standard/tests/assert/assert_options_error.phpt b/ext/standard/tests/assert/assert_options_error.phpt
index 23ca2e9e03574..f1581fe720ea7 100644
--- a/ext/standard/tests/assert/assert_options_error.phpt
+++ b/ext/standard/tests/assert/assert_options_error.phpt
@@ -10,4 +10,4 @@ try {
 }
 ?>
 --EXPECT--
-assert_options(): Argument #1 ($what) must be an ASSERT_* constant
+assert_options(): Argument #1 ($option) must be an ASSERT_* constant
diff --git a/ext/standard/tests/file/fgetcsv_error_conditions.phpt b/ext/standard/tests/file/fgetcsv_error_conditions.phpt
index 684ef7258a0a7..dd2b4d61d9fde 100644
--- a/ext/standard/tests/file/fgetcsv_error_conditions.phpt
+++ b/ext/standard/tests/file/fgetcsv_error_conditions.phpt
@@ -54,8 +54,8 @@ fgetcsv(): Argument #2 ($length) must be a greater than or equal to 0
 fgetcsv(): Argument #2 ($length) must be a greater than or equal to 0
 fgetcsv(): Argument #2 ($length) must be a greater than or equal to 0
 fgetcsv() with delimiter as NULL
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 fgetcsv() with enclosure as NULL
 fgetcsv(): Argument #4 ($enclosure) must be a single character
 fgetcsv() with delimiter & enclosure as NULL
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
diff --git a/ext/standard/tests/file/fgetcsv_variation12.phpt b/ext/standard/tests/file/fgetcsv_variation12.phpt
index faf75bdb93ae8..b2297668e7bf6 100644
--- a/ext/standard/tests/file/fgetcsv_variation12.phpt
+++ b/ext/standard/tests/file/fgetcsv_variation12.phpt
@@ -91,362 +91,362 @@ echo "Done\n";
 *** Testing fgetcsv() : with two chars as enclosure & delimiter ***
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 Done
diff --git a/ext/standard/tests/file/fgetcsv_variation19.phpt b/ext/standard/tests/file/fgetcsv_variation19.phpt
index bae8985cb554f..653f624f9d5ac 100644
--- a/ext/standard/tests/file/fgetcsv_variation19.phpt
+++ b/ext/standard/tests/file/fgetcsv_variation19.phpt
@@ -89,377 +89,377 @@ echo "Done\n";
 *** Testing fgetcsv() : with default enclosure & delimiter of two chars ***
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rb mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using rt mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using r+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using a+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using w+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+ mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+b mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 
 -- Testing fgetcsv() with file opened using x+t mode --
-fgetcsv(): Argument #3 ($delimiter) must be a single character
+fgetcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 Done
diff --git a/ext/standard/tests/file/file_get_contents_error.phpt b/ext/standard/tests/file/file_get_contents_error.phpt
index 66708c4f17a63..8e29847d8cf27 100644
--- a/ext/standard/tests/file/file_get_contents_error.phpt
+++ b/ext/standard/tests/file/file_get_contents_error.phpt
@@ -47,6 +47,6 @@ if(file_exists($file_path."/file_put_contents1.tmp")) {
 Warning: file_get_contents(/no/such/file/or/dir): Failed to open stream: No such file or directory in %s on line %d
 
 -- Testing for invalid negative maxlen values --
-file_get_contents(): Argument #5 ($maxlen) must be greater than or equal to 0
+file_get_contents(): Argument #5 ($max_length) must be greater than or equal to 0
 
 *** Done ***
diff --git a/ext/standard/tests/file/file_get_contents_error002.phpt b/ext/standard/tests/file/file_get_contents_error002.phpt
index 6624279d748ce..a58308d831b0d 100644
--- a/ext/standard/tests/file/file_get_contents_error002.phpt
+++ b/ext/standard/tests/file/file_get_contents_error002.phpt
@@ -14,4 +14,4 @@ try {
 }
 ?>
 --EXPECT--
-file_get_contents(): Argument #5 ($maxlen) must be greater than or equal to 0
+file_get_contents(): Argument #5 ($max_length) must be greater than or equal to 0
diff --git a/ext/standard/tests/file/file_get_contents_file_put_contents_error.phpt b/ext/standard/tests/file/file_get_contents_file_put_contents_error.phpt
index 5b889a19c32ac..c41a826bf958f 100644
--- a/ext/standard/tests/file/file_get_contents_file_put_contents_error.phpt
+++ b/ext/standard/tests/file/file_get_contents_file_put_contents_error.phpt
@@ -39,6 +39,6 @@ unlink($file_path."/file_put_contents1.tmp");
 Warning: file_get_contents(/no/such/file/or/dir): Failed to open stream: No such file or directory in %s on line %d
 
 -- Testing for invalid negative maxlen values --
-file_get_contents(): Argument #5 ($maxlen) must be greater than or equal to 0
+file_get_contents(): Argument #5 ($max_length) must be greater than or equal to 0
 
 *** Done ***
diff --git a/ext/standard/tests/file/fputcsv_variation2.phpt b/ext/standard/tests/file/fputcsv_variation2.phpt
index 5116940b4d25b..77b075a5f042f 100644
--- a/ext/standard/tests/file/fputcsv_variation2.phpt
+++ b/ext/standard/tests/file/fputcsv_variation2.phpt
@@ -75,649 +75,649 @@ echo "Done\n";
 *** Testing fputcsv() : with delimiter as NULL ***
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
diff --git a/ext/standard/tests/file/fputcsv_variation4.phpt b/ext/standard/tests/file/fputcsv_variation4.phpt
index a53257535a364..dc78796158095 100644
--- a/ext/standard/tests/file/fputcsv_variation4.phpt
+++ b/ext/standard/tests/file/fputcsv_variation4.phpt
@@ -75,649 +75,649 @@ echo "Done\n";
 *** Testing fputcsv() : with delimiter and enclosure as NULL ***
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
diff --git a/ext/standard/tests/file/fputcsv_variation9.phpt b/ext/standard/tests/file/fputcsv_variation9.phpt
index 405122b448ef3..b2bc895cd870b 100644
--- a/ext/standard/tests/file/fputcsv_variation9.phpt
+++ b/ext/standard/tests/file/fputcsv_variation9.phpt
@@ -75,649 +75,649 @@ echo "Done\n";
 *** Testing fputcsv() : with two chars as enclosure & delimiter ***
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in r+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in a+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in w+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+ --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+b --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
 
 -- file opened in x+t --
-fputcsv(): Argument #3 ($delimiter) must be a single character
+fputcsv(): Argument #3 ($separator) must be a single character
 int(0)
 bool(false)
 string(0) ""
diff --git a/ext/standard/tests/file/mkdir_rmdir_variation2.phpt b/ext/standard/tests/file/mkdir_rmdir_variation2.phpt
index a9e386b0b030f..4da0b374ba946 100644
--- a/ext/standard/tests/file/mkdir_rmdir_variation2.phpt
+++ b/ext/standard/tests/file/mkdir_rmdir_variation2.phpt
@@ -60,8 +60,8 @@ Warning: rmdir(%s/mkdir_variation2/): %s on line %d
 bool(false)
 
 *** Testing mkdir() and rmdir() for binary safe functionality ***
-mkdir(): Argument #1 ($pathname) must not contain any null bytes
-rmdir(): Argument #1 ($dirname) must not contain any null bytes
+mkdir(): Argument #1 ($directory) must not contain any null bytes
+rmdir(): Argument #1 ($directory) must not contain any null bytes
 
 *** Testing mkdir() with miscellaneous input ***
 bool(true)
diff --git a/ext/standard/tests/file/tempnam_variation7.phpt b/ext/standard/tests/file/tempnam_variation7.phpt
index dbe80d5ebb67c..9a0b1151c6b47 100644
--- a/ext/standard/tests/file/tempnam_variation7.phpt
+++ b/ext/standard/tests/file/tempnam_variation7.phpt
@@ -101,9 +101,9 @@ File name is => %s%etempnam_variation3.tmp%s
 File permissions are => 100600
 File created in => temp dir
 -- Iteration 6 --
-tempnam(): Argument #1 ($dir) must not contain any null bytes
+tempnam(): Argument #1 ($directory) must not contain any null bytes
 -- Iteration 7 --
-tempnam(): Argument #1 ($dir) must be of type string, array given
+tempnam(): Argument #1 ($directory) must be of type string, array given
 -- Iteration 8 --
 
 Notice: tempnam(): file created in the system's temporary directory in %stempnam_variation7.php on line %d
diff --git a/ext/standard/tests/file/touch.phpt b/ext/standard/tests/file/touch.phpt
index 32e49f31497ba..9e3972631aa67 100644
--- a/ext/standard/tests/file/touch.phpt
+++ b/ext/standard/tests/file/touch.phpt
@@ -57,5 +57,5 @@ int(100)
 
 Warning: touch(): Unable to create file /no/such/file/or/directory because %s in %s on line %d
 bool(false)
-touch(): Argument #2 ($time) cannot be null when argument #3 ($atime) is an integer
+touch(): Argument #2 ($mtime) cannot be null when argument #3 ($atime) is an integer
 Done
diff --git a/ext/standard/tests/file/userstreams.phpt b/ext/standard/tests/file/userstreams.phpt
index 101604f5abcec..9549e01e2787a 100644
--- a/ext/standard/tests/file/userstreams.phpt
+++ b/ext/standard/tests/file/userstreams.phpt
@@ -318,7 +318,7 @@ echo $data . "\n";
 
 ?>
 --EXPECT--
-stream_wrapper_register(): Argument #2 ($classname) must be a valid class name, class_not_exist given
+stream_wrapper_register(): Argument #2 ($class) must be a valid class name, class_not_exist given
 Not Registered
 Registered
 Registered
diff --git a/ext/standard/tests/filters/001.phpt b/ext/standard/tests/filters/001.phpt
index 8afe3bbaf3b93..3f0d5f5eb44e4 100644
--- a/ext/standard/tests/filters/001.phpt
+++ b/ext/standard/tests/filters/001.phpt
@@ -25,8 +25,8 @@ var_dump(stream_filter_register("------", "nonexistentclass"));
 echo "Done\n";
 ?>
 --EXPECT--
-stream_filter_register(): Argument #1 ($filtername) must be a non-empty string
-stream_filter_register(): Argument #2 ($classname) must be a non-empty string
-stream_filter_register(): Argument #1 ($filtername) must be a non-empty string
+stream_filter_register(): Argument #1 ($filter_name) must be a non-empty string
+stream_filter_register(): Argument #2 ($class) must be a non-empty string
+stream_filter_register(): Argument #1 ($filter_name) must be a non-empty string
 bool(true)
 Done
diff --git a/ext/standard/tests/general_functions/010.phpt b/ext/standard/tests/general_functions/010.phpt
index a8fefd663debd..af722ea583c63 100644
--- a/ext/standard/tests/general_functions/010.phpt
+++ b/ext/standard/tests/general_functions/010.phpt
@@ -20,5 +20,5 @@ try {
 echo "Done\n";
 ?>
 --EXPECT--
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, non-static method test::__call() cannot be called statically
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, non-static method test::__call() cannot be called statically
 Done
diff --git a/ext/standard/tests/general_functions/bug32647.phpt b/ext/standard/tests/general_functions/bug32647.phpt
index a981a7f454781..2e388d4742060 100644
--- a/ext/standard/tests/general_functions/bug32647.phpt
+++ b/ext/standard/tests/general_functions/bug32647.phpt
@@ -73,15 +73,15 @@ register_shutdown_function(array($obj,'barfoo'));
 ?>
 --EXPECTF--
 Warning: Undefined variable $obj in %s on line %d
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, first array member is not a valid class name or object
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, first array member is not a valid class name or object
 
 Warning: Undefined variable $obj in %s on line %d
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, first array member is not a valid class name or object
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, first array member is not a valid class name or object
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, class bar does not have a method "foo"
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, first array member is not a valid class name or object
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, function "bar" not found or invalid function name
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, non-static method bar::barfoo() cannot be called statically
-register_shutdown_function(): Argument #1 ($function) must be a valid callback, class bar does not have a method "foobar"
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, first array member is not a valid class name or object
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, first array member is not a valid class name or object
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, class bar does not have a method "foo"
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, first array member is not a valid class name or object
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, function "bar" not found or invalid function name
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, non-static method bar::barfoo() cannot be called statically
+register_shutdown_function(): Argument #1 ($callback) must be a valid callback, class bar does not have a method "foobar"
 foo!
 bar!
diff --git a/ext/standard/tests/general_functions/proc_open_array.phpt b/ext/standard/tests/general_functions/proc_open_array.phpt
index a37aea891ec69..9f969a1c32f24 100644
--- a/ext/standard/tests/general_functions/proc_open_array.phpt
+++ b/ext/standard/tests/general_functions/proc_open_array.phpt
@@ -68,7 +68,7 @@ proc_close($proc);
 ?>
 --EXPECT--
 Empty command array:
-proc_open(): Argument #1 ($cmd) must have at least one element
+proc_open(): Argument #1 ($command) must have at least one element
 
 Nul byte in program name:
 Command array element 1 contains a null byte
diff --git a/ext/standard/tests/general_functions/proc_open_pipes3.phpt b/ext/standard/tests/general_functions/proc_open_pipes3.phpt
index 96ce75bd0ccac..f5801ad63e435 100644
--- a/ext/standard/tests/general_functions/proc_open_pipes3.phpt
+++ b/ext/standard/tests/general_functions/proc_open_pipes3.phpt
@@ -32,7 +32,7 @@ echo "END\n";
 ?>
 --EXPECTF--
 Warning: proc_open(): pi is not a valid descriptor spec/mode in %s on line %d
-proc_open(): Argument #2 ($descriptorspec) must only contain arrays and streams
+proc_open(): Argument #2 ($descriptor_spec) must only contain arrays and streams
 array(4) {
   [3]=>
   resource(%d) of type (Unknown)
diff --git a/ext/standard/tests/general_functions/putenv.phpt b/ext/standard/tests/general_functions/putenv.phpt
index 163fa7e4a708e..40799b25790f2 100644
--- a/ext/standard/tests/general_functions/putenv.phpt
+++ b/ext/standard/tests/general_functions/putenv.phpt
@@ -37,6 +37,6 @@ bool(true)
 string(0) ""
 bool(true)
 bool(false)
-putenv(): Argument #1 ($setting) must have a valid syntax
-putenv(): Argument #1 ($setting) must have a valid syntax
+putenv(): Argument #1 ($assignment) must have a valid syntax
+putenv(): Argument #1 ($assignment) must have a valid syntax
 Done
diff --git a/ext/standard/tests/general_functions/register_tick_function_error.phpt b/ext/standard/tests/general_functions/register_tick_function_error.phpt
index 82564a83b425e..adcc20215ed91 100644
--- a/ext/standard/tests/general_functions/register_tick_function_error.phpt
+++ b/ext/standard/tests/general_functions/register_tick_function_error.phpt
@@ -11,4 +11,4 @@ try {
 }
 ?>
 --EXPECT--
-register_tick_function(): Argument #1 ($function) must be a valid tick callback, "a" given
+register_tick_function(): Argument #1 ($callback) must be a valid tick callback, "a" given
diff --git a/ext/standard/tests/image/bug79877.phpt b/ext/standard/tests/image/bug79877.phpt
index fa68fc963a75a..53532deb31ba7 100644
--- a/ext/standard/tests/image/bug79877.phpt
+++ b/ext/standard/tests/image/bug79877.phpt
@@ -5,7 +5,7 @@ Bug #79877 (getimagesize function silently truncates after a null byte)
 var_dump(getimagesize("/tmp/a.png\0xx"));
 ?>
 --EXPECTF--
-Fatal error: Uncaught ValueError: getimagesize(): Argument #1 ($image_path) must not contain any null bytes in %s:%d
+Fatal error: Uncaught ValueError: getimagesize(): Argument #1 ($filename) must not contain any null bytes in %s:%d
 Stack trace:
 #0 %s(%d): getimagesize('/tmp/a.png\x00xx')
 #1 {main}
diff --git a/ext/standard/tests/math/abs_variation.phpt b/ext/standard/tests/math/abs_variation.phpt
index 4a40ab4e37cdb..6b7a184cbd93d 100644
--- a/ext/standard/tests/math/abs_variation.phpt
+++ b/ext/standard/tests/math/abs_variation.phpt
@@ -100,25 +100,25 @@ int(1)
 int(0)
 
 -- Iteration 7 --
-abs(): Argument #1 ($number) must be of type int|float, string given
+abs(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 8 --
-abs(): Argument #1 ($number) must be of type int|float, string given
+abs(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 9 --
-abs(): Argument #1 ($number) must be of type int|float, array given
+abs(): Argument #1 ($num) must be of type int|float, array given
 
 -- Iteration 10 --
-abs(): Argument #1 ($number) must be of type int|float, string given
+abs(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 11 --
-abs(): Argument #1 ($number) must be of type int|float, string given
+abs(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 12 --
-abs(): Argument #1 ($number) must be of type int|float, string given
+abs(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 13 --
-abs(): Argument #1 ($number) must be of type int|float, classA given
+abs(): Argument #1 ($num) must be of type int|float, classA given
 
 -- Iteration 14 --
 int(0)
@@ -127,4 +127,4 @@ int(0)
 int(0)
 
 -- Iteration 16 --
-abs(): Argument #1 ($number) must be of type int|float, resource given
+abs(): Argument #1 ($num) must be of type int|float, resource given
diff --git a/ext/standard/tests/math/base_convert_error.phpt b/ext/standard/tests/math/base_convert_error.phpt
index b2cf396ae3047..3d253606e0346 100644
--- a/ext/standard/tests/math/base_convert_error.phpt
+++ b/ext/standard/tests/math/base_convert_error.phpt
@@ -29,6 +29,6 @@ try {
 ?>
 --EXPECT--
 *** Testing base_convert() : error conditions ***
-base_convert(): Argument #2 ($frombase) must be between 2 and 36 (inclusive)
-base_convert(): Argument #3 ($tobase) must be between 2 and 36 (inclusive)
-base_convert(): Argument #1 ($number) must be of type string, classA given
+base_convert(): Argument #2 ($from_base) must be between 2 and 36 (inclusive)
+base_convert(): Argument #3 ($to_base) must be between 2 and 36 (inclusive)
+base_convert(): Argument #1 ($num) must be of type string, classA given
diff --git a/ext/standard/tests/math/base_convert_variation1.phpt b/ext/standard/tests/math/base_convert_variation1.phpt
index a1365b3e74723..8d8e0ff3a295b 100644
--- a/ext/standard/tests/math/base_convert_variation1.phpt
+++ b/ext/standard/tests/math/base_convert_variation1.phpt
@@ -145,7 +145,7 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 19 --
-base_convert(): Argument #1 ($number) must be of type string, array given
+base_convert(): Argument #1 ($num) must be of type string, array given
 
 -- Iteration 20 --
 
@@ -169,4 +169,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 25 --
-base_convert(): Argument #1 ($number) must be of type string, resource given
+base_convert(): Argument #1 ($num) must be of type string, resource given
diff --git a/ext/standard/tests/math/ceil_variation1.phpt b/ext/standard/tests/math/ceil_variation1.phpt
index a21ffe609d17a..ce61442f6554c 100644
--- a/ext/standard/tests/math/ceil_variation1.phpt
+++ b/ext/standard/tests/math/ceil_variation1.phpt
@@ -93,25 +93,25 @@ float(1)
 float(0)
 
 -- Iteration 7 --
-ceil(): Argument #1 ($number) must be of type int|float, string given
+ceil(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 8 --
-ceil(): Argument #1 ($number) must be of type int|float, string given
+ceil(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 9 --
-ceil(): Argument #1 ($number) must be of type int|float, array given
+ceil(): Argument #1 ($num) must be of type int|float, array given
 
 -- Iteration 10 --
-ceil(): Argument #1 ($number) must be of type int|float, string given
+ceil(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 11 --
-ceil(): Argument #1 ($number) must be of type int|float, string given
+ceil(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 12 --
-ceil(): Argument #1 ($number) must be of type int|float, string given
+ceil(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 13 --
-ceil(): Argument #1 ($number) must be of type int|float, classA given
+ceil(): Argument #1 ($num) must be of type int|float, classA given
 
 -- Iteration 14 --
 float(0)
@@ -120,4 +120,4 @@ float(0)
 float(0)
 
 -- Iteration 16 --
-ceil(): Argument #1 ($number) must be of type int|float, resource given
+ceil(): Argument #1 ($num) must be of type int|float, resource given
diff --git a/ext/standard/tests/math/decbin_basic.phpt b/ext/standard/tests/math/decbin_basic.phpt
index 1366997dcf128..54b771ca26c20 100644
--- a/ext/standard/tests/math/decbin_basic.phpt
+++ b/ext/standard/tests/math/decbin_basic.phpt
@@ -36,7 +36,7 @@ string(4) "1010"
 string(12) "111101101110"
 string(12) "111101101110"
 string(6) "100111"
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 string(1) "1"
 string(1) "0"
 string(1) "0"
diff --git a/ext/standard/tests/math/decbin_basiclong_64bit.phpt b/ext/standard/tests/math/decbin_basiclong_64bit.phpt
index 6e4dfa826b0e3..16fd6b97b8033 100644
--- a/ext/standard/tests/math/decbin_basiclong_64bit.phpt
+++ b/ext/standard/tests/math/decbin_basiclong_64bit.phpt
@@ -55,7 +55,7 @@ string(32) "11111111111111111111111111111101"
 --- testing: 9223372036854775806 ---
 string(63) "111111111111111111111111111111111111111111111111111111111111110"
 --- testing: 9.2233720368548E+18 ---
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 --- testing: -9223372036854775807 ---
 string(64) "1000000000000000000000000000000000000000000000000000000000000001"
 --- testing: -9.2233720368548E+18 ---
diff --git a/ext/standard/tests/math/decbin_variation1_64bit.phpt b/ext/standard/tests/math/decbin_variation1_64bit.phpt
index ed278bfed04c4..f9e1b19b29030 100644
--- a/ext/standard/tests/math/decbin_variation1_64bit.phpt
+++ b/ext/standard/tests/math/decbin_variation1_64bit.phpt
@@ -104,10 +104,10 @@ string(14) "11000000111001"
 string(64) "1111111111111111111111111111111111111111111111111111011011010111"
 
 -- Iteration 5 --
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(4) "1010"
@@ -143,25 +143,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-decbin(): Argument #1 ($number) must be of type int, array given
+decbin(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-decbin(): Argument #1 ($number) must be of type int, classA given
+decbin(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -170,4 +170,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-decbin(): Argument #1 ($number) must be of type int, resource given
+decbin(): Argument #1 ($num) must be of type int, resource given
diff --git a/ext/standard/tests/math/dechex_basic.phpt b/ext/standard/tests/math/dechex_basic.phpt
index 729685c206084..92e9c426b3755 100644
--- a/ext/standard/tests/math/dechex_basic.phpt
+++ b/ext/standard/tests/math/dechex_basic.phpt
@@ -36,7 +36,7 @@ string(1) "a"
 string(3) "f6e"
 string(3) "f6e"
 string(2) "27"
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 string(1) "1"
 string(1) "0"
 string(1) "0"
diff --git a/ext/standard/tests/math/dechex_basiclong_64bit.phpt b/ext/standard/tests/math/dechex_basiclong_64bit.phpt
index c7727c5ce8883..85051ea4567ba 100644
--- a/ext/standard/tests/math/dechex_basiclong_64bit.phpt
+++ b/ext/standard/tests/math/dechex_basiclong_64bit.phpt
@@ -55,7 +55,7 @@ string(8) "fffffffd"
 --- testing: 9223372036854775806 ---
 string(16) "7ffffffffffffffe"
 --- testing: 9.2233720368548E+18 ---
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 --- testing: -9223372036854775807 ---
 string(16) "8000000000000001"
 --- testing: -9.2233720368548E+18 ---
diff --git a/ext/standard/tests/math/dechex_variation1_64bit.phpt b/ext/standard/tests/math/dechex_variation1_64bit.phpt
index 981ccba493c56..020bbcd22ce73 100644
--- a/ext/standard/tests/math/dechex_variation1_64bit.phpt
+++ b/ext/standard/tests/math/dechex_variation1_64bit.phpt
@@ -105,10 +105,10 @@ string(4) "3039"
 string(16) "fffffffffffff6d7"
 
 -- Iteration 5 --
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(1) "a"
@@ -144,25 +144,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-dechex(): Argument #1 ($number) must be of type int, array given
+dechex(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-dechex(): Argument #1 ($number) must be of type int, classA given
+dechex(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -171,4 +171,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-dechex(): Argument #1 ($number) must be of type int, resource given
+dechex(): Argument #1 ($num) must be of type int, resource given
diff --git a/ext/standard/tests/math/decoct_basic.phpt b/ext/standard/tests/math/decoct_basic.phpt
index 4afdeb466e43c..9252789b2464b 100644
--- a/ext/standard/tests/math/decoct_basic.phpt
+++ b/ext/standard/tests/math/decoct_basic.phpt
@@ -36,7 +36,7 @@ string(2) "12"
 string(4) "7556"
 string(4) "7556"
 string(2) "47"
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 string(1) "1"
 string(1) "0"
 string(1) "0"
diff --git a/ext/standard/tests/math/decoct_basiclong_64bit.phpt b/ext/standard/tests/math/decoct_basiclong_64bit.phpt
index 0ebc7203f2eff..a4e951176cd0b 100644
--- a/ext/standard/tests/math/decoct_basiclong_64bit.phpt
+++ b/ext/standard/tests/math/decoct_basiclong_64bit.phpt
@@ -55,7 +55,7 @@ string(11) "37777777775"
 --- testing: 9223372036854775806 ---
 string(21) "777777777777777777776"
 --- testing: 9.2233720368548E+18 ---
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 --- testing: -9223372036854775807 ---
 string(22) "1000000000000000000001"
 --- testing: -9.2233720368548E+18 ---
diff --git a/ext/standard/tests/math/decoct_variation1_64bit.phpt b/ext/standard/tests/math/decoct_variation1_64bit.phpt
index 35a9c892883c9..2ecc212844c0b 100644
--- a/ext/standard/tests/math/decoct_variation1_64bit.phpt
+++ b/ext/standard/tests/math/decoct_variation1_64bit.phpt
@@ -106,10 +106,10 @@ string(5) "30071"
 string(22) "1777777777777777773327"
 
 -- Iteration 5 --
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(2) "12"
@@ -145,25 +145,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-decoct(): Argument #1 ($number) must be of type int, array given
+decoct(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-decoct(): Argument #1 ($number) must be of type int, classA given
+decoct(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -172,4 +172,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-decoct(): Argument #1 ($number) must be of type int, resource given
+decoct(): Argument #1 ($num) must be of type int, resource given
diff --git a/ext/standard/tests/math/floor_variation1.phpt b/ext/standard/tests/math/floor_variation1.phpt
index 95228b4418aac..0b5f09f27dce5 100644
--- a/ext/standard/tests/math/floor_variation1.phpt
+++ b/ext/standard/tests/math/floor_variation1.phpt
@@ -93,25 +93,25 @@ float(1)
 float(0)
 
 -- Iteration 7 --
-floor(): Argument #1 ($number) must be of type int|float, string given
+floor(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 8 --
-floor(): Argument #1 ($number) must be of type int|float, string given
+floor(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 9 --
-floor(): Argument #1 ($number) must be of type int|float, array given
+floor(): Argument #1 ($num) must be of type int|float, array given
 
 -- Iteration 10 --
-floor(): Argument #1 ($number) must be of type int|float, string given
+floor(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 11 --
-floor(): Argument #1 ($number) must be of type int|float, string given
+floor(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 12 --
-floor(): Argument #1 ($number) must be of type int|float, string given
+floor(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 13 --
-floor(): Argument #1 ($number) must be of type int|float, classA given
+floor(): Argument #1 ($num) must be of type int|float, classA given
 
 -- Iteration 14 --
 float(0)
@@ -120,4 +120,4 @@ float(0)
 float(0)
 
 -- Iteration 16 --
-floor(): Argument #1 ($number) must be of type int|float, resource given
+floor(): Argument #1 ($num) must be of type int|float, resource given
diff --git a/ext/standard/tests/math/round_variation1.phpt b/ext/standard/tests/math/round_variation1.phpt
index ab8eecbe84227..b6ce56dd4acad 100644
--- a/ext/standard/tests/math/round_variation1.phpt
+++ b/ext/standard/tests/math/round_variation1.phpt
@@ -137,25 +137,25 @@ float(1)
 float(0)
 
 -- Iteration 17 --
-round(): Argument #1 ($number) must be of type int|float, string given
+round(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 18 --
-round(): Argument #1 ($number) must be of type int|float, string given
+round(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 19 --
-round(): Argument #1 ($number) must be of type int|float, array given
+round(): Argument #1 ($num) must be of type int|float, array given
 
 -- Iteration 20 --
-round(): Argument #1 ($number) must be of type int|float, string given
+round(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 21 --
-round(): Argument #1 ($number) must be of type int|float, string given
+round(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 22 --
-round(): Argument #1 ($number) must be of type int|float, string given
+round(): Argument #1 ($num) must be of type int|float, string given
 
 -- Iteration 23 --
-round(): Argument #1 ($number) must be of type int|float, classA given
+round(): Argument #1 ($num) must be of type int|float, classA given
 
 -- Iteration 24 --
 float(0)
@@ -164,4 +164,4 @@ float(0)
 float(0)
 
 -- Iteration 26 --
-round(): Argument #1 ($number) must be of type int|float, resource given
+round(): Argument #1 ($num) must be of type int|float, resource given
diff --git a/ext/standard/tests/streams/stream_get_contents_negative_length.phpt b/ext/standard/tests/streams/stream_get_contents_negative_length.phpt
index 7bfe8d5724d73..d229c0ef6bfbf 100644
--- a/ext/standard/tests/streams/stream_get_contents_negative_length.phpt
+++ b/ext/standard/tests/streams/stream_get_contents_negative_length.phpt
@@ -14,6 +14,6 @@ try {
 }
 
 ?>
---EXPECTF--
+--EXPECT--
 string(2) "bc"
-stream_get_contents(): Argument #2 ($maxlength) must be greater than or equal to -1
+stream_get_contents(): Argument #2 ($max_length) must be greater than or equal to -1
diff --git a/ext/standard/tests/strings/addcslashes_001.phpt b/ext/standard/tests/strings/addcslashes_001.phpt
index 50a57129e5b36837e10656c9b15dc716818d88a9..be6b18559faa64304ecf5399d0057352e5ec9775 100644
GIT binary patch
delta 19
bcmaFK^O|SF0cN(u<dW2);>|~xmofnWRLKYl

delta 17
ZcmaFO^O9%70cMt*%;J*G$C#Hg0RTnO2SWe=

diff --git a/ext/standard/tests/strings/bug40754.phpt b/ext/standard/tests/strings/bug40754.phpt
index be9d89912dc63..42eed969abfdf 100644
--- a/ext/standard/tests/strings/bug40754.phpt
+++ b/ext/standard/tests/strings/bug40754.phpt
@@ -88,8 +88,8 @@ var_dump(substr("abcde", $v, $v));
 --EXPECT--
 string(4) "bcde"
 string(6) "abcdex"
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 substr_count(): Argument #3 ($offset) must be contained in argument #1 ($haystack)
 substr_compare(): Argument #3 ($offset) must be contained in argument #1 ($main_str)
 stripos(): Argument #3 ($offset) must be contained in argument #1 ($haystack)
diff --git a/ext/standard/tests/strings/bug61116.phpt b/ext/standard/tests/strings/bug61116.phpt
index d03489560b231..f8f76cd5047e9 100644
--- a/ext/standard/tests/strings/bug61116.phpt
+++ b/ext/standard/tests/strings/bug61116.phpt
@@ -10,7 +10,7 @@ Function [ <internal:standard> function htmlspecialchars ] {
 
   - Parameters [4] {
     Parameter #0 [ <required> string $string ]
-    Parameter #1 [ <optional> int $quote_style = ENT_COMPAT ]
+    Parameter #1 [ <optional> int $flags = ENT_COMPAT ]
     Parameter #2 [ <optional> ?string $encoding = null ]
     Parameter #3 [ <optional> bool $double_encode = true ]
   }
@@ -21,7 +21,7 @@ Function [ <internal:standard> function get_html_translation_table ] {
 
   - Parameters [3] {
     Parameter #0 [ <optional> int $table = HTML_SPECIALCHARS ]
-    Parameter #1 [ <optional> int $quote_style = ENT_COMPAT ]
+    Parameter #1 [ <optional> int $flags = ENT_COMPAT ]
     Parameter #2 [ <optional> string $encoding = "UTF-8" ]
   }
   - Return [ array ]
diff --git a/ext/standard/tests/strings/chunk_split_variation5.phpt b/ext/standard/tests/strings/chunk_split_variation5.phpt
index 31a7b2c0389a540b9f6744905002e7e297e71e2f..9e59d6765877650794a6bf8bd9eb994c4374349b 100644
GIT binary patch
delta 57
tcmZ1{uuNdXJr=f{)V%bPjLAA|YMXgjB^aUn%{pxDF!to#>_G@+k^nED65#*<

delta 73
ycmZ1`uufpZJr<7SjMBX9oYcI@yd097|FWnuqKHiX%fh?ak1Y{NbSrxhiV^_BEg4S$

diff --git a/ext/standard/tests/strings/chunk_split_variation8.phpt b/ext/standard/tests/strings/chunk_split_variation8.phpt
index 4a21455ecfd41..b0c889494e404 100644
--- a/ext/standard/tests/strings/chunk_split_variation8.phpt
+++ b/ext/standard/tests/strings/chunk_split_variation8.phpt
@@ -53,14 +53,14 @@ for($count = 0; $count < count($values); $count++) {
 --EXPECT--
 *** Testing chunk_split() : different 'chunklen' with heredoc 'str' ***
 -- Iteration 1 --
-chunk_split(): Argument #2 ($chunklen) must be greater than 0
+chunk_split(): Argument #2 ($length) must be greater than 0
 -- Iteration 2 --
 string(504) "T:::h:::i:::s:::':::s::: :::h:::e:::r:::e:::d:::o:::c::: :::s:::t:::r:::i:::n:::g::: :::w:::i:::t:::h::: :::	::: :::a:::n:::d::: :::
 ::: :::w:::h:::i:::t:::e::: :::s:::p:::a:::c:::e::: :::c:::h:::a:::r:::.:::
 :::I:::t::: :::h:::a:::s::: :::_:::s:::p:::e:::c:::i:::@:::l::: :::c:::h:::@:::r:::$::: :::2:::2:::2:::2::: :::!:::!:::!:::N:::o:::w::: :::\:::k::: :::a:::s::: :::e:::s:::c:::a:::p:::e::: :::c:::h:::a:::r::: :::t:::o::: :::t:::e:::s:::t:::
 :::c:::h:::u:::n:::k:::_:::s:::p:::l:::i:::t:::(:::):::"
 -- Iteration 3 --
-chunk_split(): Argument #2 ($chunklen) must be greater than 0
+chunk_split(): Argument #2 ($length) must be greater than 0
 -- Iteration 4 --
 string(129) "This's heredoc string with 	 and 
  white space char.
@@ -77,6 +77,6 @@ string(129) "This's heredoc string with 	 and
 It has _speci@l ch@r$ 2222 !!!Now \k as escape char to test
 chunk_split():::"
 -- Iteration 7 --
-chunk_split(): Argument #2 ($chunklen) must be of type int, float given
+chunk_split(): Argument #2 ($length) must be of type int, float given
 -- Iteration 8 --
-chunk_split(): Argument #2 ($chunklen) must be greater than 0
+chunk_split(): Argument #2 ($length) must be greater than 0
diff --git a/ext/standard/tests/strings/implode1.phpt b/ext/standard/tests/strings/implode1.phpt
index fdc9d329a8fad443258bc5c4945d85c74096a47f..c1c1599eb7b56c5ddfb62286e2a2a0b696ca0938 100644
GIT binary patch
delta 79
zcmbQKzd(Njryyr>YC&RAVo83{W?sQ!W(0RKub|rIRU(fVSrdzj5-TU?ic3viBUTFM
MsZaJ3mxS|l09nx+fdBvi

delta 67
zcmZ3WKU04LryxsuPHF1oJ`uIe7J|OaVBY3F5e}xwO~MkB*NW9bX^zQ#;=Ge<#UzpV
FLICvF73Tl|

diff --git a/ext/standard/tests/strings/join_variation1.phpt b/ext/standard/tests/strings/join_variation1.phpt
index a21251aec2a28..7a806349ce9cb 100644
--- a/ext/standard/tests/strings/join_variation1.phpt
+++ b/ext/standard/tests/strings/join_variation1.phpt
@@ -119,15 +119,15 @@ string(29) "element11.07654321E-9element2"
 -- Iteration 9 --
 string(19) "element10.5element2"
 -- Iteration 10 --
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 -- Iteration 11 --
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 -- Iteration 12 --
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 -- Iteration 13 --
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 -- Iteration 14 --
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 -- Iteration 15 --
 string(17) "element11element2"
 -- Iteration 16 --
@@ -147,7 +147,7 @@ string(16) "element1element2"
 -- Iteration 23 --
 string(16) "element1element2"
 -- Iteration 24 --
-join(): Argument #1 ($glue) must be of type array|string, resource given
+join(): Argument #1 ($separator) must be of type array|string, resource given
 -- Iteration 25 --
 string(16) "element1element2"
 -- Iteration 26 --
diff --git a/ext/standard/tests/strings/join_variation2.phpt b/ext/standard/tests/strings/join_variation2.phpt
index 5fc83dde794db..57f570b258703 100644
--- a/ext/standard/tests/strings/join_variation2.phpt
+++ b/ext/standard/tests/strings/join_variation2.phpt
@@ -102,47 +102,47 @@ echo "Done\n";
 
 --- Testing join() by supplying different values for 'pieces' argument ---
 -- Iteration 1 --
-join(): Argument #2 ($pieces) must be of type ?array, int given
+join(): Argument #2 ($array) must be of type ?array, int given
 -- Iteration 2 --
-join(): Argument #2 ($pieces) must be of type ?array, int given
+join(): Argument #2 ($array) must be of type ?array, int given
 -- Iteration 3 --
-join(): Argument #2 ($pieces) must be of type ?array, int given
+join(): Argument #2 ($array) must be of type ?array, int given
 -- Iteration 4 --
-join(): Argument #2 ($pieces) must be of type ?array, int given
+join(): Argument #2 ($array) must be of type ?array, int given
 -- Iteration 5 --
-join(): Argument #2 ($pieces) must be of type ?array, float given
+join(): Argument #2 ($array) must be of type ?array, float given
 -- Iteration 6 --
-join(): Argument #2 ($pieces) must be of type ?array, float given
+join(): Argument #2 ($array) must be of type ?array, float given
 -- Iteration 7 --
-join(): Argument #2 ($pieces) must be of type ?array, float given
+join(): Argument #2 ($array) must be of type ?array, float given
 -- Iteration 8 --
-join(): Argument #2 ($pieces) must be of type ?array, float given
+join(): Argument #2 ($array) must be of type ?array, float given
 -- Iteration 9 --
-join(): Argument #2 ($pieces) must be of type ?array, float given
+join(): Argument #2 ($array) must be of type ?array, float given
 -- Iteration 10 --
-join(): Argument #2 ($pieces) must be of type ?array, bool given
+join(): Argument #2 ($array) must be of type ?array, bool given
 -- Iteration 11 --
-join(): Argument #2 ($pieces) must be of type ?array, bool given
+join(): Argument #2 ($array) must be of type ?array, bool given
 -- Iteration 12 --
-join(): Argument #2 ($pieces) must be of type ?array, bool given
+join(): Argument #2 ($array) must be of type ?array, bool given
 -- Iteration 13 --
-join(): Argument #2 ($pieces) must be of type ?array, bool given
+join(): Argument #2 ($array) must be of type ?array, bool given
 -- Iteration 14 --
-join(): Argument #2 ($pieces) must be of type ?array, string given
+join(): Argument #2 ($array) must be of type ?array, string given
 -- Iteration 15 --
-join(): Argument #2 ($pieces) must be of type ?array, string given
+join(): Argument #2 ($array) must be of type ?array, string given
 -- Iteration 16 --
-join(): Argument #2 ($pieces) must be of type ?array, test given
+join(): Argument #2 ($array) must be of type ?array, test given
 -- Iteration 17 --
-join(): Argument #2 ($pieces) must be of type ?array, string given
+join(): Argument #2 ($array) must be of type ?array, string given
 -- Iteration 18 --
-join(): Argument #2 ($pieces) must be of type ?array, string given
+join(): Argument #2 ($array) must be of type ?array, string given
 -- Iteration 19 --
 join(): Argument #1 ($pieces) must be of type array, string given
 -- Iteration 20 --
 join(): Argument #1 ($pieces) must be of type array, string given
 -- Iteration 21 --
-join(): Argument #2 ($pieces) must be of type ?array, resource given
+join(): Argument #2 ($array) must be of type ?array, resource given
 -- Iteration 22 --
 join(): Argument #1 ($pieces) must be of type array, string given
 -- Iteration 23 --
diff --git a/ext/standard/tests/strings/join_variation4.phpt b/ext/standard/tests/strings/join_variation4.phpt
index 6a9ff44297ed5777d70aba8c343ee8a44dc0f444..8c8c8b9092d94edd0c97ab8461d3fa17861699e2 100644
GIT binary patch
delta 22
dcmdlcuv=imaTd<v)PlsK#FG4?&8JzinE`0b2-g4r

delta 17
YcmdljuuWjYaTb>JoYK_I7g(~H0YB0Pvj6}9

diff --git a/ext/standard/tests/strings/join_variation5.phpt b/ext/standard/tests/strings/join_variation5.phpt
index 50dd08cbf2af3..9e5898d8c1079 100644
--- a/ext/standard/tests/strings/join_variation5.phpt
+++ b/ext/standard/tests/strings/join_variation5.phpt
@@ -35,7 +35,7 @@ Warning: Array to string conversion in %s on line %d
 
 Warning: Array to string conversion in %s on line %d
 string(27) "ArrayTESTArrayTESTPHPTEST50"
-join(): Argument #1 ($glue) must be of type string, array given
+join(): Argument #1 ($separator) must be of type string, array given
 
 Warning: Array to string conversion in %s on line %d
 
diff --git a/ext/standard/tests/strings/levenshtein_error_conditions.phpt b/ext/standard/tests/strings/levenshtein_error_conditions.phpt
index bd1b80742b19c..71af71297f653 100644
--- a/ext/standard/tests/strings/levenshtein_error_conditions.phpt
+++ b/ext/standard/tests/strings/levenshtein_error_conditions.phpt
@@ -25,7 +25,7 @@ try {
 --EXPECT--
 --- String 1 ---
 int(254)
-levenshtein(): Argument #1 ($str1) must be less than 256 characters
+levenshtein(): Argument #1 ($string1) must be less than 256 characters
 --- String 2 ---
 int(254)
-levenshtein(): Argument #2 ($str2) must be less than 256 characters
+levenshtein(): Argument #2 ($string2) must be less than 256 characters
diff --git a/ext/standard/tests/strings/metaphone.phpt b/ext/standard/tests/strings/metaphone.phpt
index 0356c1fd69909..6b8f5c1c89d9d 100644
--- a/ext/standard/tests/strings/metaphone.phpt
+++ b/ext/standard/tests/strings/metaphone.phpt
@@ -30,7 +30,7 @@ echo "Done\n";
 --EXPECT--
 string(0) ""
 string(0) ""
-metaphone(): Argument #2 ($phonemes) must be greater than or equal to 0
+metaphone(): Argument #2 ($max_phonemes) must be greater than or equal to 0
 string(6) "FLTFRS"
 string(6) "FLTFRS"
 string(26) "0FLFRWRTKRFLNKHTLSLN0KLTR0"
diff --git a/ext/standard/tests/strings/str_pad_variation1.phpt b/ext/standard/tests/strings/str_pad_variation1.phpt
index d0f953a184ae2..cb71e61156fcd 100644
--- a/ext/standard/tests/strings/str_pad_variation1.phpt
+++ b/ext/standard/tests/strings/str_pad_variation1.phpt
@@ -31,6 +31,6 @@ var_dump( str_pad($input, $php_int_max_pad_length) );
 ?>
 --EXPECTF--
 *** Testing str_pad() function: with large value for for 'pad_length' argument ***
-str_pad(): Argument #2 ($pad_length) must be of type int, float given
+str_pad(): Argument #2 ($length) must be of type int, float given
 
 Fatal error: Allowed memory size of %d bytes exhausted%s(tried to allocate %d bytes) in %s on line %d
diff --git a/ext/standard/tests/strings/str_repeat.phpt b/ext/standard/tests/strings/str_repeat.phpt
index 7919dfda219894cfd4f9c1d2b1642da93ec32c65..3069f6bfe97f9bcb3a9523885b5ae82c49c1477f 100644
GIT binary patch
delta 17
Ycmew<`b%`f1uoW-%-q!C$yc~k0Z97?WdHyG

delta 16
Xcmew*`crhn1umA{(wvgXSGiOHLA?hB

diff --git a/ext/standard/tests/strings/strcspn.phpt b/ext/standard/tests/strings/strcspn.phpt
index bdeac113bbe8c..7fc2ca3f4007a 100644
--- a/ext/standard/tests/strings/strcspn.phpt
+++ b/ext/standard/tests/strings/strcspn.phpt
@@ -21,4 +21,4 @@ string(4) "1234"
 int(0)
 int(7)
 int(6)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
diff --git a/ext/standard/tests/strings/strcspn_variation11.phpt b/ext/standard/tests/strings/strcspn_variation11.phpt
index 3c69373af093f..0ff3c614c3718 100644
--- a/ext/standard/tests/strings/strcspn_variation11.phpt
+++ b/ext/standard/tests/strings/strcspn_variation11.phpt
@@ -79,219 +79,219 @@ echo "Done"
 
 -- Iteration 1 --
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 2 --
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 3 --
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 4 --
 int(2)
@@ -299,71 +299,71 @@ int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 5 --
 int(24)
@@ -371,71 +371,71 @@ int(23)
 int(22)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(24)
 int(23)
 int(22)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(24)
 int(23)
 int(22)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(24)
 int(23)
 int(22)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 6 --
 int(28)
@@ -443,71 +443,71 @@ int(27)
 int(26)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(28)
 int(27)
 int(26)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(28)
 int(27)
 int(26)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(28)
 int(27)
 int(26)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 7 --
 int(20)
@@ -515,71 +515,71 @@ int(19)
 int(18)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(20)
 int(19)
 int(18)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(20)
 int(19)
 int(18)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(20)
 int(19)
 int(18)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 8 --
 int(21)
@@ -587,71 +587,71 @@ int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 9 --
 int(5)
@@ -659,71 +659,71 @@ int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(12)
 int(11)
 int(10)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(12)
 int(11)
 int(10)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(12)
 int(11)
 int(10)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(12)
 int(11)
 int(10)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(12)
 int(11)
 int(10)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 10 --
 int(16)
@@ -731,71 +731,71 @@ int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(16)
 int(15)
 int(14)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 11 --
 int(0)
@@ -803,71 +803,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 12 --
 int(0)
@@ -875,71 +875,71 @@ int(5)
 int(4)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(5)
 int(4)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(3)
 int(2)
 int(1)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(3)
 int(2)
 int(1)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(13)
 int(12)
 int(11)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 13 --
 int(0)
@@ -947,71 +947,71 @@ int(12)
 int(11)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(12)
 int(11)
 int(0)
 int(1)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(3)
 int(2)
 int(1)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(3)
 int(2)
 int(1)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 14 --
 int(5)
@@ -1019,71 +1019,71 @@ int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 15 --
 int(5)
@@ -1091,71 +1091,71 @@ int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(11)
 int(10)
 int(9)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 16 --
 int(5)
@@ -1163,71 +1163,71 @@ int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(14)
 int(13)
 int(12)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(6)
 int(5)
 int(4)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 17 --
 int(21)
@@ -1235,69 +1235,69 @@ int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(0)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(21)
 int(20)
 int(19)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(5)
 int(4)
 int(3)
 int(1)
 int(2)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 Done
diff --git a/ext/standard/tests/strings/strcspn_variation12.phpt b/ext/standard/tests/strings/strcspn_variation12.phpt
index 7367e20dce900..d43ff90599bf8 100644
--- a/ext/standard/tests/strings/strcspn_variation12.phpt
+++ b/ext/standard/tests/strings/strcspn_variation12.phpt
@@ -81,2399 +81,2399 @@ echo "Done"
 
 -- Iteration 1 --
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 2 --
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 3 --
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 4 --
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 5 --
 int(0)
 int(1)
 int(2)
 int(23)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(22)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(21)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(23)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(22)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(21)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(23)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(22)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(21)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 6 --
 int(0)
 int(1)
 int(2)
 int(19)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(18)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(17)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(19)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(18)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(17)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(6)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(16)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(15)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(14)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(19)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(18)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(17)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(16)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(15)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(14)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 7 --
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 8 --
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 9 --
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(12)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(12)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(12)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 10 --
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(8)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(8)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(9)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(8)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 11 --
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(12)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(12)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(11)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(10)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(6)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(5)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strcspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strcspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 Done
diff --git a/ext/standard/tests/strings/strip_tags_variation2.phpt b/ext/standard/tests/strings/strip_tags_variation2.phpt
index 640e353ab2b81..421f8a62ae4ea 100644
--- a/ext/standard/tests/strings/strip_tags_variation2.phpt
+++ b/ext/standard/tests/strings/strip_tags_variation2.phpt
@@ -125,5 +125,5 @@ string(10) "helloworld"
 -- Iteration 20 --
 string(10) "helloworld"
 -- Iteration 21 --
-strip_tags(): Argument #2 ($allowable_tags) must be of type array|string|null, resource given
+strip_tags(): Argument #2 ($allowed_tags) must be of type array|string|null, resource given
 Done
diff --git a/ext/standard/tests/strings/strpbrk_error.phpt b/ext/standard/tests/strings/strpbrk_error.phpt
index 78550ab009b9a..3d7f84e948bfb 100644
--- a/ext/standard/tests/strings/strpbrk_error.phpt
+++ b/ext/standard/tests/strings/strpbrk_error.phpt
@@ -14,4 +14,4 @@ try {
 ?>
 --EXPECT--
 -- Testing strpbrk() function with empty second argument --
-strpbrk(): Argument #2 ($char_list) must be a non-empty string
+strpbrk(): Argument #2 ($characters) must be a non-empty string
diff --git a/ext/standard/tests/strings/strspn_variation11.phpt b/ext/standard/tests/strings/strspn_variation11.phpt
index 8e30a6d900a24..c66e86b7f570c 100644
--- a/ext/standard/tests/strings/strspn_variation11.phpt
+++ b/ext/standard/tests/strings/strspn_variation11.phpt
@@ -79,219 +79,219 @@ echo "Done"
 
 -- Iteration 1 --
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 2 --
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 3 --
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 4 --
 int(0)
@@ -299,71 +299,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(2)
 int(1)
 int(0)
 int(1)
 int(2)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(1)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 5 --
 int(0)
@@ -371,71 +371,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 6 --
 int(0)
@@ -443,71 +443,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(1)
 int(2)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 7 --
 int(0)
@@ -515,71 +515,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 8 --
 int(0)
@@ -587,71 +587,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 9 --
 int(0)
@@ -659,71 +659,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(1)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 10 --
 int(0)
@@ -731,71 +731,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 11 --
 int(0)
@@ -803,71 +803,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 12 --
 int(0)
@@ -875,71 +875,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 13 --
 int(0)
@@ -947,71 +947,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(4)
 int(3)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 14 --
 int(0)
@@ -1019,71 +1019,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 15 --
 int(0)
@@ -1091,71 +1091,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 16 --
 int(0)
@@ -1163,71 +1163,71 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 17 --
 int(0)
@@ -1235,69 +1235,69 @@ int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(4)
 int(3)
 int(2)
 int(0)
 int(1)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 Done
diff --git a/ext/standard/tests/strings/strspn_variation12.phpt b/ext/standard/tests/strings/strspn_variation12.phpt
index 9fec20735c4b6..a43b85a696760 100644
--- a/ext/standard/tests/strings/strspn_variation12.phpt
+++ b/ext/standard/tests/strings/strspn_variation12.phpt
@@ -81,2795 +81,2795 @@ echo "Done"
 
 -- Iteration 1 --
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 2 --
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 3 --
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-int(0)
-int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+int(0)
+int(1)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 4 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(1)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 5 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 6 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 7 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 8 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 9 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+int(0)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 10 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 
 -- Iteration 11 --
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(4)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(3)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(1)
 int(2)
 int(2)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
 int(0)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #4 ($len) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
-strspn(): Argument #3 ($start) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #4 ($length) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
+strspn(): Argument #3 ($offset) must be contained in argument #1 ($str)
 Done
diff --git a/ext/standard/tests/strings/substr_replace_error.phpt b/ext/standard/tests/strings/substr_replace_error.phpt
index 6fc0c2e203553..165cc1e6913d1 100644
--- a/ext/standard/tests/strings/substr_replace_error.phpt
+++ b/ext/standard/tests/strings/substr_replace_error.phpt
@@ -27,5 +27,5 @@ try {
 *** Testing substr_replace() : error conditions ***
 
 -- Testing substr_replace() function with start and length as arrays but string not--
-substr_replace(): Argument #3 ($start) cannot be an array when working on a single string
+substr_replace(): Argument #3 ($offset) cannot be an array when working on a single string
 substr_replace(): Argument #4 ($length) cannot be an array when working on a single string
diff --git a/ext/standard/tests/strings/vfprintf_error3.phpt b/ext/standard/tests/strings/vfprintf_error3.phpt
index 703bc73ad8ced..24991552e0a35 100644
--- a/ext/standard/tests/strings/vfprintf_error3.phpt
+++ b/ext/standard/tests/strings/vfprintf_error3.phpt
@@ -48,6 +48,6 @@ unlink( $file );
 --EXPECT--
 -- Testing vfprintf() function with wrong variable types as argument --
 vfprintf(): Argument #2 ($format) must be of type string, array given
-vfprintf(): Argument #3 ($args) must be of type array, string given
+vfprintf(): Argument #3 ($values) must be of type array, string given
 Unknown format specifier "y"
 string(0) ""
diff --git a/ext/standard/tests/strings/vfprintf_error4.phpt b/ext/standard/tests/strings/vfprintf_error4.phpt
index fcbd86466dd5d..b635c7781e956 100644
--- a/ext/standard/tests/strings/vfprintf_error4.phpt
+++ b/ext/standard/tests/strings/vfprintf_error4.phpt
@@ -34,5 +34,5 @@ unlink( $file );
 ?>
 --EXPECT--
 -- Testing vfprintf() function with other strangeties  --
-vfprintf(): Argument #1 ($handle) must be of type resource, string given
+vfprintf(): Argument #1 ($stream) must be of type resource, string given
 Error found: Argument number must be greater than zero.
diff --git a/ext/standard/tests/strings/vfprintf_variation1.phpt b/ext/standard/tests/strings/vfprintf_variation1.phpt
index c9274d383bec4..36d983817024f 100644
--- a/ext/standard/tests/strings/vfprintf_variation1.phpt
+++ b/ext/standard/tests/strings/vfprintf_variation1.phpt
@@ -60,7 +60,7 @@ unlink( $file );
 ?>
 --EXPECT--
 *** Testing vfprintf() : variation functionality ***
-vfprintf(): Argument #3 ($args) must be of type array, null given
+vfprintf(): Argument #3 ($values) must be of type array, null given
 string(17) "Foo is 30 and bar"
 int(17)
 string(14) "Foobar testing"
diff --git a/ext/standard/tests/strings/vprintf_variation2.phpt b/ext/standard/tests/strings/vprintf_variation2.phpt
index 1f04a6395dd35..22f2f152d85a2 100644
--- a/ext/standard/tests/strings/vprintf_variation2.phpt
+++ b/ext/standard/tests/strings/vprintf_variation2.phpt
@@ -99,70 +99,70 @@ fclose($file_handle);
 *** Testing vprintf() : with unexpected values for args argument ***
 
 -- Iteration 1 --
-vprintf(): Argument #2 ($args) must be of type array, int given
+vprintf(): Argument #2 ($values) must be of type array, int given
 
 -- Iteration 2 --
-vprintf(): Argument #2 ($args) must be of type array, int given
+vprintf(): Argument #2 ($values) must be of type array, int given
 
 -- Iteration 3 --
-vprintf(): Argument #2 ($args) must be of type array, int given
+vprintf(): Argument #2 ($values) must be of type array, int given
 
 -- Iteration 4 --
-vprintf(): Argument #2 ($args) must be of type array, int given
+vprintf(): Argument #2 ($values) must be of type array, int given
 
 -- Iteration 5 --
-vprintf(): Argument #2 ($args) must be of type array, float given
+vprintf(): Argument #2 ($values) must be of type array, float given
 
 -- Iteration 6 --
-vprintf(): Argument #2 ($args) must be of type array, float given
+vprintf(): Argument #2 ($values) must be of type array, float given
 
 -- Iteration 7 --
-vprintf(): Argument #2 ($args) must be of type array, float given
+vprintf(): Argument #2 ($values) must be of type array, float given
 
 -- Iteration 8 --
-vprintf(): Argument #2 ($args) must be of type array, float given
+vprintf(): Argument #2 ($values) must be of type array, float given
 
 -- Iteration 9 --
-vprintf(): Argument #2 ($args) must be of type array, float given
+vprintf(): Argument #2 ($values) must be of type array, float given
 
 -- Iteration 10 --
-vprintf(): Argument #2 ($args) must be of type array, null given
+vprintf(): Argument #2 ($values) must be of type array, null given
 
 -- Iteration 11 --
-vprintf(): Argument #2 ($args) must be of type array, null given
+vprintf(): Argument #2 ($values) must be of type array, null given
 
 -- Iteration 12 --
-vprintf(): Argument #2 ($args) must be of type array, bool given
+vprintf(): Argument #2 ($values) must be of type array, bool given
 
 -- Iteration 13 --
-vprintf(): Argument #2 ($args) must be of type array, bool given
+vprintf(): Argument #2 ($values) must be of type array, bool given
 
 -- Iteration 14 --
-vprintf(): Argument #2 ($args) must be of type array, bool given
+vprintf(): Argument #2 ($values) must be of type array, bool given
 
 -- Iteration 15 --
-vprintf(): Argument #2 ($args) must be of type array, bool given
+vprintf(): Argument #2 ($values) must be of type array, bool given
 
 -- Iteration 16 --
-vprintf(): Argument #2 ($args) must be of type array, string given
+vprintf(): Argument #2 ($values) must be of type array, string given
 
 -- Iteration 17 --
-vprintf(): Argument #2 ($args) must be of type array, string given
+vprintf(): Argument #2 ($values) must be of type array, string given
 
 -- Iteration 18 --
-vprintf(): Argument #2 ($args) must be of type array, string given
+vprintf(): Argument #2 ($values) must be of type array, string given
 
 -- Iteration 19 --
-vprintf(): Argument #2 ($args) must be of type array, string given
+vprintf(): Argument #2 ($values) must be of type array, string given
 
 -- Iteration 20 --
-vprintf(): Argument #2 ($args) must be of type array, sample given
+vprintf(): Argument #2 ($values) must be of type array, sample given
 
 -- Iteration 21 --
-vprintf(): Argument #2 ($args) must be of type array, null given
+vprintf(): Argument #2 ($values) must be of type array, null given
 
 -- Iteration 22 --
-vprintf(): Argument #2 ($args) must be of type array, null given
+vprintf(): Argument #2 ($values) must be of type array, null given
 
 -- Iteration 23 --
-vprintf(): Argument #2 ($args) must be of type array, resource given
+vprintf(): Argument #2 ($values) must be of type array, resource given
diff --git a/ext/standard/tests/strings/wordwrap_error.phpt b/ext/standard/tests/strings/wordwrap_error.phpt
index 26020f1e17da8..b93bb80565b89 100644
--- a/ext/standard/tests/strings/wordwrap_error.phpt
+++ b/ext/standard/tests/strings/wordwrap_error.phpt
@@ -47,7 +47,7 @@ var_dump( wordwrap($str, $width, $break, $cut) );
 -- width = 0 & cut = false --
 string(39) "testing<br />\nwordwrap<br />\nfunction"
 -- width = 0 & cut = true --
-wordwrap(): Argument #4 ($cut) cannot be true when argument #2 ($width) is 0
+wordwrap(): Argument #4 ($cut_long_words) cannot be true when argument #2 ($width) is 0
 -- width = -10 & cut = false --
 string(39) "testing<br />\nwordwrap<br />\nfunction"
 -- width = -10 & cut = true --

From 212de89f434406da3d2df8f59099967b80f8bcaf Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 14:31:06 +0200
Subject: [PATCH 07/10] More test updates

---
 ext/date/tests/microtime_error.phpt                         | 4 ++--
 ext/phar/tests/fgc_edgecases.phpt                           | 2 +-
 .../tests/ReflectionParameter_canBePassedByValue.phpt       | 2 +-
 ext/sysvshm/tests/001.phpt                                  | 6 +++---
 sapi/cli/tests/004.phpt                                     | 4 ++--
 5 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/ext/date/tests/microtime_error.phpt b/ext/date/tests/microtime_error.phpt
index 32cc64bb9df85..ce13875e67b1a 100644
--- a/ext/date/tests/microtime_error.phpt
+++ b/ext/date/tests/microtime_error.phpt
@@ -46,11 +46,11 @@ float(%s)
     int(0)
   }
 }
-microtime(): Argument #1 ($getAsFloat) must be of type bool, array given
+microtime(): Argument #1 ($as_float) must be of type bool, array given
 
 --> bad arg: object(stdClass)#%d (0) {
 }
-microtime(): Argument #1 ($getAsFloat) must be of type bool, stdClass given
+microtime(): Argument #1 ($as_float) must be of type bool, stdClass given
 
 --> bad arg: int(1)
 float(%s)
diff --git a/ext/phar/tests/fgc_edgecases.phpt b/ext/phar/tests/fgc_edgecases.phpt
index a30ca7df193da..aad575749bd37 100644
--- a/ext/phar/tests/fgc_edgecases.phpt
+++ b/ext/phar/tests/fgc_edgecases.phpt
@@ -71,7 +71,7 @@ echo file_get_contents("./hi", 0, $context, 50000);
 echo file_get_contents("./hi");
 echo file_get_contents("./hi", 0, $context, 0, 0);
 ?>
-file_get_contents(): Argument #5 ($maxlen) must be greater than or equal to 0
+file_get_contents(): Argument #5 ($max_length) must be greater than or equal to 0
 test
 test
 <?php
diff --git a/ext/reflection/tests/ReflectionParameter_canBePassedByValue.phpt b/ext/reflection/tests/ReflectionParameter_canBePassedByValue.phpt
index 28214681e820b..849ade406397e 100644
--- a/ext/reflection/tests/ReflectionParameter_canBePassedByValue.phpt
+++ b/ext/reflection/tests/ReflectionParameter_canBePassedByValue.phpt
@@ -37,7 +37,7 @@ echo "Done.\n";
 --EXPECT--
 => array_multisort:
 
-Name: array1
+Name: array
 Is passed by reference: yes
 Can be passed by value: yes
 
diff --git a/ext/sysvshm/tests/001.phpt b/ext/sysvshm/tests/001.phpt
index e9d00bc6dc24c..487d862e8f55e 100644
--- a/ext/sysvshm/tests/001.phpt
+++ b/ext/sysvshm/tests/001.phpt
@@ -33,9 +33,9 @@ var_dump(ftok(__FILE__,"q"));
 echo "Done\n";
 ?>
 --EXPECTF--
-ftok(): Argument #1 ($pathname) cannot be empty
-ftok(): Argument #2 ($proj) must be a single character
-ftok(): Argument #2 ($proj) must be a single character
+ftok(): Argument #1 ($filename) cannot be empty
+ftok(): Argument #2 ($project_id) must be a single character
+ftok(): Argument #2 ($project_id) must be a single character
 
 Warning: ftok(): ftok() failed - No such file or directory in %s on line %d
 int(-1)
diff --git a/sapi/cli/tests/004.phpt b/sapi/cli/tests/004.phpt
index fb0ae99ddcdb9..094161a8fafcf 100644
--- a/sapi/cli/tests/004.phpt
+++ b/sapi/cli/tests/004.phpt
@@ -20,10 +20,10 @@ string(45) "Exception: Function unknown() does not exist
 "
 string(42) "Exception: Function echo() does not exist
 "
-string(154) "Function [ <internal:standard> function phpinfo ] {
+string(155) "Function [ <internal:standard> function phpinfo ] {
 
   - Parameters [1] {
-    Parameter #0 [ <optional> int $what = INFO_ALL ]
+    Parameter #0 [ <optional> int $flags = INFO_ALL ]
   }
   - Return [ bool ]
 }

From 72b661b8e04c211a5cefab2fcb3e7e9067082c28 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 15:10:23 +0200
Subject: [PATCH 08/10] Rename some $path to $directory

---
 ext/standard/basic_functions.stub.php  | 6 +++---
 ext/standard/basic_functions_arginfo.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/ext/standard/basic_functions.stub.php b/ext/standard/basic_functions.stub.php
index 75876ceab651c..5b8103f036fec 100755
--- a/ext/standard/basic_functions.stub.php
+++ b/ext/standard/basic_functions.stub.php
@@ -694,16 +694,16 @@ function utf8_decode(string $string): string {}
  * @param resource|null $context
  * @return resource|false
  */
-function opendir(string $path, $context = null) {}
+function opendir(string $directory, $context = null) {}
 
 /** @param resource $context */
-function getdir(string $path, $context = null): Directory|false {}
+function getdir(string $directory, $context = null): Directory|false {}
 
 /**
  * @param resource|null $context
  * @alias getdir
  */
-function dir(string $path, $context = null): Directory|false {}
+function dir(string $directory, $context = null): Directory|false {}
 
 /** @param resource|null $dir_handle */
 function closedir($dir_handle = null): void {}
diff --git a/ext/standard/basic_functions_arginfo.h b/ext/standard/basic_functions_arginfo.h
index 83e96e40a89bc..5ee5b9602900b 100644
--- a/ext/standard/basic_functions_arginfo.h
+++ b/ext/standard/basic_functions_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 66d077cacb14825267889aa41369bd09416b5e41 */
+ * Stub hash: af5b921b66f7dd68ba8c771199825a439a07dba0 */
 
 ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_set_time_limit, 0, 1, _IS_BOOL, 0)
 	ZEND_ARG_TYPE_INFO(0, seconds, IS_LONG, 0)
@@ -1090,12 +1090,12 @@ ZEND_END_ARG_INFO()
 #define arginfo_utf8_decode arginfo_base64_encode
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_opendir, 0, 0, 1)
-	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 
 ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_getdir, 0, 1, Directory, MAY_BE_FALSE)
-	ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, directory, IS_STRING, 0)
 	ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, context, "null")
 ZEND_END_ARG_INFO()
 

From 1a7b9754d385caa7897bf9ebf60e58ffb8ec31ce Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 15:17:50 +0200
Subject: [PATCH 09/10] 32-bit test fixes

---
 .../tests/math/decbin_variation1.phpt         | 24 +++++++++----------
 .../tests/math/dechex_variation1.phpt         | 24 +++++++++----------
 .../tests/math/decoct_variation1.phpt         | 24 +++++++++----------
 3 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/ext/standard/tests/math/decbin_variation1.phpt b/ext/standard/tests/math/decbin_variation1.phpt
index 53f4bcaab4687..fd9addc721c7c 100644
--- a/ext/standard/tests/math/decbin_variation1.phpt
+++ b/ext/standard/tests/math/decbin_variation1.phpt
@@ -1,5 +1,5 @@
 --TEST--
-Test decbin() function : usage variations - different data types as $number arg
+Test decbin() function : usage variations - different data types as $num arg
 --INI--
 precision=14
 --SKIPIF--
@@ -106,10 +106,10 @@ string(14) "11000000111001"
 string(32) "11111111111111111111011011010111"
 
 -- Iteration 5 --
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(4) "1010"
@@ -118,7 +118,7 @@ string(4) "1010"
 string(32) "11111111111111111111111111110110"
 
 -- Iteration 9 --
-decbin(): Argument #1 ($number) must be of type int, float given
+decbin(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 10 --
 string(1) "0"
@@ -145,25 +145,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-decbin(): Argument #1 ($number) must be of type int, array given
+decbin(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-decbin(): Argument #1 ($number) must be of type int, string given
+decbin(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-decbin(): Argument #1 ($number) must be of type int, classA given
+decbin(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -172,4 +172,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-decbin(): Argument #1 ($number) must be of type int, resource given
+decbin(): Argument #1 ($num) must be of type int, resource given
diff --git a/ext/standard/tests/math/dechex_variation1.phpt b/ext/standard/tests/math/dechex_variation1.phpt
index 5dbe004a07ac5..8add97f7a24d1 100644
--- a/ext/standard/tests/math/dechex_variation1.phpt
+++ b/ext/standard/tests/math/dechex_variation1.phpt
@@ -1,5 +1,5 @@
 --TEST--
-Test dechex() function : usage variations - different data types as $number arg
+Test dechex() function : usage variations - different data types as $num arg
 --INI--
 precision=14
 --SKIPIF--
@@ -106,10 +106,10 @@ string(4) "3039"
 string(8) "fffff6d7"
 
 -- Iteration 5 --
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(1) "a"
@@ -118,7 +118,7 @@ string(1) "a"
 string(8) "fffffff6"
 
 -- Iteration 9 --
-dechex(): Argument #1 ($number) must be of type int, float given
+dechex(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 10 --
 string(1) "0"
@@ -145,25 +145,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-dechex(): Argument #1 ($number) must be of type int, array given
+dechex(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-dechex(): Argument #1 ($number) must be of type int, string given
+dechex(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-dechex(): Argument #1 ($number) must be of type int, classA given
+dechex(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -172,4 +172,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-dechex(): Argument #1 ($number) must be of type int, resource given
+dechex(): Argument #1 ($num) must be of type int, resource given
diff --git a/ext/standard/tests/math/decoct_variation1.phpt b/ext/standard/tests/math/decoct_variation1.phpt
index 79125661757df..a236ea53678bc 100644
--- a/ext/standard/tests/math/decoct_variation1.phpt
+++ b/ext/standard/tests/math/decoct_variation1.phpt
@@ -1,5 +1,5 @@
 --TEST--
-Test decoct() function : usage variations - different data types as $number arg
+Test decoct() function : usage variations - different data types as $num arg
 --INI--
 precision=14
 --SKIPIF--
@@ -106,10 +106,10 @@ string(5) "30071"
 string(11) "37777773327"
 
 -- Iteration 5 --
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 6 --
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 7 --
 string(2) "12"
@@ -118,7 +118,7 @@ string(2) "12"
 string(11) "37777777766"
 
 -- Iteration 9 --
-decoct(): Argument #1 ($number) must be of type int, float given
+decoct(): Argument #1 ($num) must be of type int, float given
 
 -- Iteration 10 --
 string(1) "0"
@@ -145,25 +145,25 @@ string(1) "1"
 string(1) "0"
 
 -- Iteration 18 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 19 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 20 --
-decoct(): Argument #1 ($number) must be of type int, array given
+decoct(): Argument #1 ($num) must be of type int, array given
 
 -- Iteration 21 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 22 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 23 --
-decoct(): Argument #1 ($number) must be of type int, string given
+decoct(): Argument #1 ($num) must be of type int, string given
 
 -- Iteration 24 --
-decoct(): Argument #1 ($number) must be of type int, classA given
+decoct(): Argument #1 ($num) must be of type int, classA given
 
 -- Iteration 25 --
 string(1) "0"
@@ -172,4 +172,4 @@ string(1) "0"
 string(1) "0"
 
 -- Iteration 27 --
-decoct(): Argument #1 ($number) must be of type int, resource given
+decoct(): Argument #1 ($num) must be of type int, resource given

From 313307c68ac2989b1a9bd41223461be87060a551 Mon Sep 17 00:00:00 2001
From: Nikita Popov <nikita.ppv@gmail.com>
Date: Tue, 29 Sep 2020 15:36:38 +0200
Subject: [PATCH 10/10] Fix phar test

---
 ext/phar/tests/opendir_edgecases.phpt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ext/phar/tests/opendir_edgecases.phpt b/ext/phar/tests/opendir_edgecases.phpt
index 53250740a05e4..9cfd65c841081 100644
--- a/ext/phar/tests/opendir_edgecases.phpt
+++ b/ext/phar/tests/opendir_edgecases.phpt
@@ -55,7 +55,7 @@ include $pname . '/foo';
 <?php unlink(__DIR__ . '/' . basename(__FILE__, '.clean.php') . '.phar.php'); ?>
 <?php rmdir(__DIR__ . '/opendir_edgecases');
 --EXPECTF--
-opendir(): Argument #1 ($path) must be of type string, array given
+opendir(): Argument #1 ($directory) must be of type string, array given
 .
 ..
 foo