diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 957d93f984967..7e3e5fe38146b 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -3725,6 +3725,40 @@ static zend_always_inline void zend_memnstr_ex_pre(unsigned int td[], const char
 
 ZEND_API const char* ZEND_FASTCALL zend_memnstr_ex(const char *haystack, const char *needle, size_t needle_len, const char *end) /* {{{ */
 {
+#if defined(__SSE2__)
+	if (needle_len >= 4) {
+		const char *p;
+		__m128i first_chars = _mm_set1_epi8(needle[0]);
+		__m128i last_chars = _mm_set1_epi8(needle[needle_len - 1]);
+
+		for (p = haystack; p <= end - needle_len; p += 16) {
+			__m128i haystack_first_chars = _mm_loadu_si128((__m128i*)p);
+			__m128i haystack_last_chars = _mm_loadu_si128((__m128i*)(p + needle_len - 1));
+			__m128i eq_first = _mm_cmpeq_epi8(first_chars, haystack_first_chars);
+			__m128i eq_last = _mm_cmpeq_epi8(last_chars, haystack_last_chars);
+			unsigned long mask = _mm_movemask_epi8(_mm_and_si128(eq_first, eq_last));
+
+			while (mask > 0) {
+				unsigned long bit = 1UL << __builtin_ctzl(mask);
+				size_t ofs = __builtin_ctzl(mask);
+				if (memcmp(p + ofs + 1, needle + 1, needle_len - 2) == 0) {
+					return p + ofs;
+				}
+				mask &= ~bit;
+			}
+		}
+
+		// Handle the remainder of the string if its length is not a multiple of 16
+		for (; p <= end - needle_len; p++) {
+			if (p[0] == needle[0] && memcmp(p + 1, needle + 1, needle_len - 1) == 0) {
+				return p;
+			}
+		}
+
+		return NULL;
+	}
+#endif
+
 	unsigned int td[256];
 	size_t i;
 	const char *p;
@@ -3739,12 +3773,7 @@ ZEND_API const char* ZEND_FASTCALL zend_memnstr_ex(const char *haystack, const c
 	end -= needle_len;
 
 	while (p <= end) {
-		for (i = 0; i < needle_len; i++) {
-			if (needle[i] != p[i]) {
-				break;
-			}
-		}
-		if (i == needle_len) {
+		if (memcmp(p, needle, needle_len) == 0) {
 			return p;
 		}
 		if (UNEXPECTED(p == end)) {
diff --git a/benchmark.php b/benchmark.php
new file mode 100644
index 0000000000000..ad1ee62ab91d8
--- /dev/null
+++ b/benchmark.php
@@ -0,0 +1,26 @@
+<?php
+
+function benchmark_strtoupper(string $str) {
+    $start = microtime(true);
+    for ($i = 0; $i < 100000; $i++) {
+        strtoupper($str);
+    }
+    $end = microtime(true);
+    return $end - $start;
+}
+
+$short_ascii = 'abcdefghijklmnopqrstuvwxyz';
+$long_ascii = str_repeat($short_ascii, 1000);
+$short_mixed = 'aBcDeFgHiJkLmNoPqRsTuVwXyZ';
+$long_mixed = str_repeat($short_mixed, 1000);
+$short_upper = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+$long_upper = str_repeat($short_upper, 1000);
+
+echo "Benchmarking current strtoupper implementation...\n";
+
+echo "Short ASCII string: " . benchmark_strtoupper($short_ascii) . "s\n";
+echo "Long ASCII string: " . benchmark_strtoupper($long_ascii) . "s\n";
+echo "Short mixed-case string: " . benchmark_strtoupper($short_mixed) . "s\n";
+echo "Long mixed-case string: " . benchmark_strtoupper($long_mixed) . "s\n";
+echo "Short uppercase string: " . benchmark_strtoupper($short_upper) . "s\n";
+echo "Long uppercase string: " . benchmark_strtoupper($long_upper) . "s\n";
diff --git a/benchmark_array_combine.php b/benchmark_array_combine.php
new file mode 100644
index 0000000000000..0f262c64cb4b0
--- /dev/null
+++ b/benchmark_array_combine.php
@@ -0,0 +1,38 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    // Run the function multiple times to get a more stable reading
+    for ($i = 0; $i < 10; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    printf("%-40s: %8.4f seconds\n", $name, ($end - $start));
+}
+
+const LARGE_SIZE = 1000000;
+
+// --- Scenario 1: Packed Indexed Arrays (Target for optimization) ---
+$indexed_keys = range(0, LARGE_SIZE - 1);
+$indexed_values = range(0, LARGE_SIZE - 1);
+
+benchmark("Packed Indexed Arrays", function() use ($indexed_keys, $indexed_values) {
+    $a = array_combine($indexed_keys, $indexed_values);
+});
+
+
+// --- Scenario 2: Associative Arrays (Check for regressions) ---
+$assoc_keys = [];
+$assoc_values = [];
+for ($i = 0; $i < LARGE_SIZE; $i++) {
+    $assoc_keys[] = "key_" . $i;
+    $assoc_values[] = $i;
+}
+
+benchmark("Associative Arrays", function() use ($assoc_keys, $assoc_values) {
+    $a = array_combine($assoc_keys, $assoc_values);
+});
+
+echo "\n";
+
+?>
diff --git a/benchmark_grapheme_str_split.php b/benchmark_grapheme_str_split.php
new file mode 100644
index 0000000000000..1a047d28f34aa
--- /dev/null
+++ b/benchmark_grapheme_str_split.php
@@ -0,0 +1,48 @@
+<?php
+
+function benchmark($name, $func) {
+    // A relatively low iteration count because grapheme operations can be intensive.
+    $iterations = 500;
+    $start = microtime(true);
+    for ($i = 0; $i < $iterations; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo str_pad($name, 45) . ": " . number_format($end - $start, 6) . "s\n";
+}
+
+echo "Benchmarking current grapheme_str_split implementation...\n";
+
+// A long string (~50KB) mixing ASCII, multi-byte, and complex graphemes.
+$long_string = str_repeat("Hello world! Это тест. The quick brown 👨‍👩‍👧‍👦 fox. Á, B́, Ć.", 200);
+
+// ===== TEST CASES =====
+
+// Case 1: Simple ASCII string
+benchmark("Simple ASCII string", function() {
+    grapheme_str_split("abcdefghijklmnopqrstuvwxyz");
+});
+
+// Case 2: Multi-byte UTF-8 string (Cyrillic)
+benchmark("Multi-byte UTF-8 string (Cyrillic)", function() {
+    grapheme_str_split("абвгдеёжзийклмнопрстуфхцчшщъыьэюя");
+});
+
+// Case 3: Complex Graphemes (Combining Marks)
+// 'e' with 3 combining marks is one grapheme
+benchmark("Complex Graphemes (Combining Marks)", function() {
+    grapheme_str_split("é̄̃");
+});
+
+// Case 4: Complex Graphemes (Emoji)
+// Family emoji and woman with skin tone modifier are single graphemes
+benchmark("Complex Graphemes (Emoji)", function() {
+    grapheme_str_split("👨‍👩‍👧‍👦👩🏽‍💻");
+});
+
+// Case 5: Long mixed string
+benchmark("Long mixed string", function() use ($long_string) {
+    grapheme_str_split($long_string);
+});
+
+?>
diff --git a/benchmark_range.php b/benchmark_range.php
new file mode 100644
index 0000000000000..243198686dfa6
--- /dev/null
+++ b/benchmark_range.php
@@ -0,0 +1,44 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    $func();
+    $end = microtime(true);
+    printf("%-40s: %8.4f seconds\n", $name, $end - $start);
+}
+
+const LARGE_INT = 10000000;
+const LARGE_FLOAT = 10000000.0;
+
+// --- Integer Benchmarks ---
+benchmark("Integer Range (1 to 10,000,000)", function() {
+    $a = range(1, LARGE_INT);
+});
+
+benchmark("Integer Range (10,000,000 to 1)", function() {
+    $a = range(LARGE_INT, 1);
+});
+
+benchmark("Integer Range with Step (1 to 10,000,000, step 2)", function() {
+    $a = range(1, LARGE_INT, 2);
+});
+
+
+// --- Float Benchmarks ---
+benchmark("Float Range (1.0 to 10,000,000.0)", function() {
+    $a = range(1.0, LARGE_FLOAT);
+});
+
+benchmark("Float Range with Step (10,000,000.0 to 1.0, step 2.5)", function() {
+    $a = range(LARGE_FLOAT, 1.0, 2.5);
+});
+
+
+// --- Character Benchmark ---
+benchmark("Character Range ('a' to 'z')", function() {
+    $a = range('a', 'z');
+});
+
+echo "\n";
+
+?>
diff --git a/benchmark_str_decrement.php b/benchmark_str_decrement.php
new file mode 100644
index 0000000000000..348a851c59d89
--- /dev/null
+++ b/benchmark_str_decrement.php
@@ -0,0 +1,51 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    // Using a smaller iteration count because string operations can be slow
+    for ($i = 0; $i < 20000; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo "$name: " . ($end - $start) . "s\n";
+}
+
+echo "Benchmarking current str_decrement implementation...\n";
+
+// Case 1: Simple numeric string, no borrow needed.
+$s1 = "123456789123456789";
+benchmark("Simple numeric string", function() use ($s1) {
+    str_decrement($s1);
+});
+
+// Case 2: Long numeric string with full borrow. This is the key case for my optimization.
+$s2 = "1" . str_repeat("0", 50);
+benchmark("Long numeric string with full borrow", function() use ($s2) {
+    str_decrement($s2);
+});
+
+// Case 3: Simple alphanumeric string, no borrow needed.
+$s3 = "abcdefg9";
+benchmark("Simple alphanumeric string", function() use ($s3) {
+    str_decrement($s3);
+});
+
+// Case 4: Long alphanumeric string with numeric borrow.
+$s4 = "b" . str_repeat("0", 50);
+benchmark("Long alphanumeric with numeric borrow", function() use ($s4) {
+    str_decrement($s4);
+});
+
+// Case 5: Long alphanumeric string with letter borrow.
+$s5 = "z" . str_repeat("a", 50);
+benchmark("Long alphanumeric with letter borrow", function() use ($s5) {
+    str_decrement($s5);
+});
+
+// Case 6: A long string that does not trigger the leading-zero optimization.
+$s6 = "2" . str_repeat("0", 50);
+benchmark("Long numeric string without leading-zero result", function() use ($s6) {
+    str_decrement($s6);
+});
+
+?>
diff --git a/benchmark_str_ends_with.php b/benchmark_str_ends_with.php
new file mode 100644
index 0000000000000..f9c02d30cb3a4
--- /dev/null
+++ b/benchmark_str_ends_with.php
@@ -0,0 +1,49 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    // This function is very fast, so a high iteration count is needed.
+    for ($i = 0; $i < 500000; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo str_pad($name, 40) . ": " . number_format($end - $start, 6) . "s\n";
+}
+
+echo "Benchmarking current str_ends_with implementation...\n";
+
+$long_haystack = "This is a very long string that is used for benchmarking purposes to see how the function performs with a significant amount of data to process.";
+$long_needle_match = "a significant amount of data to process.";
+$long_needle_no_match = "a significant amount of data to process!";
+
+// Case 1: Haystack shorter than needle (fast path)
+benchmark("Haystack shorter than needle", function() {
+    str_ends_with("short", "this is much longer");
+});
+
+// Case 2: Matching short needle
+benchmark("Matching short needle", function() use ($long_haystack) {
+    str_ends_with($long_haystack, "process.");
+});
+
+// Case 3: Non-matching short needle
+benchmark("Non-matching short needle", function() use ($long_haystack) {
+    str_ends_with($long_haystack, "process!");
+});
+
+// Case 4: Matching long needle
+benchmark("Matching long needle", function() use ($long_haystack, $long_needle_match) {
+    str_ends_with($long_haystack, $long_needle_match);
+});
+
+// Case 5: Non-matching long needle
+benchmark("Non-matching long needle", function() use ($long_haystack, $long_needle_no_match) {
+    str_ends_with($long_haystack, $long_needle_no_match);
+});
+
+// Case 6: Matching empty needle (edge case)
+benchmark("Matching empty needle", function() use ($long_haystack) {
+    str_ends_with($long_haystack, "");
+});
+
+?>
diff --git a/benchmark_str_increment.php b/benchmark_str_increment.php
new file mode 100644
index 0000000000000..7d85cfcdad1aa
--- /dev/null
+++ b/benchmark_str_increment.php
@@ -0,0 +1,50 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    for ($i = 0; $i < 20000; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo "$name: " . ($end - $start) . "s\n";
+}
+
+echo "Benchmarking current str_increment implementation...\n";
+
+// Case 1: Simple numeric string, no carry needed.
+$s1 = "123456788";
+benchmark("Simple numeric string", function() use ($s1) {
+    str_increment($s1);
+});
+
+// Case 2: Long numeric string with full carry. This is the key case for my optimization.
+$s2 = str_repeat("9", 50);
+benchmark("Long numeric string with full carry", function() use ($s2) {
+    str_increment($s2);
+});
+
+// Case 3: Simple alphanumeric string, no carry needed.
+$s3 = "abcde8";
+benchmark("Simple alphanumeric string", function() use ($s3) {
+    str_increment($s3);
+});
+
+// Case 4: Long alphanumeric string with numeric carry.
+$s4 = "a" . str_repeat("9", 50);
+benchmark("Long alphanumeric with numeric carry", function() use ($s4) {
+    str_increment($s4);
+});
+
+// Case 5: Long alphanumeric string with full letter and numeric carry.
+$s5 = "z" . str_repeat("9", 50);
+benchmark("Long alphanumeric with full carry", function() use ($s5) {
+    str_increment($s5);
+});
+
+// Case 6: A long string that does not trigger reallocation.
+$s6 = "8" . str_repeat("9", 50);
+benchmark("Long numeric string without reallocation", function() use ($s6) {
+    str_increment($s6);
+});
+
+?>
diff --git a/benchmark_str_ireplace.php b/benchmark_str_ireplace.php
new file mode 100644
index 0000000000000..8157506eb2a03
--- /dev/null
+++ b/benchmark_str_ireplace.php
@@ -0,0 +1,47 @@
+<?php
+
+function benchmark($name, $func) {
+    $start = microtime(true);
+    // A lower iteration count because str_ireplace can be very slow with arrays on long strings.
+    for ($i = 0; $i < 500; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo str_pad($name, 50) . ": " . number_format($end - $start, 6) . "s\n";
+}
+
+echo "Benchmarking current str_ireplace implementation...\n";
+
+// A long string (~22KB) with a variety of characters to search for.
+$long_haystack = str_repeat("The quick brown fox jumps over the lazy dog. ", 500);
+
+// An array of search terms that will all be found.
+$search_array = ['the', 'quick', 'brown', 'fox', 'jumps', 'over', 'lazy', 'dog'];
+$replace_array = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'];
+
+// An array of search terms that will not be found.
+$search_array_no_match = ['xylophone', 'yak', 'zebra', 'walrus', 'vulture', 'unicorn', 'tiger', 'snake'];
+
+// ===== TEST CASES =====
+
+// Case 1: Simple string search (no arrays) for baseline comparison.
+benchmark("Simple string search", function() use ($long_haystack) {
+    str_ireplace('fox', 'cat', $long_haystack);
+});
+
+// Case 2: Array search, single replace. THIS IS THE PRIMARY OPTIMIZATION TARGET.
+benchmark("Array search, single replacement", function() use ($long_haystack, $search_array) {
+    str_ireplace($search_array, 'REPLACED', $long_haystack);
+});
+
+// Case 3: Array search, array replace. THIS IS THE PRIMARY OPTIMIZATION TARGET.
+benchmark("Array search, array replacement", function() use ($long_haystack, $search_array, $replace_array) {
+    str_ireplace($search_array, $replace_array, $long_haystack);
+});
+
+// Case 4: Array search with no matches. To ensure no performance regression.
+benchmark("Array search, no matches", function() use ($long_haystack, $search_array_no_match) {
+    str_ireplace($search_array_no_match, 'REPLACED', $long_haystack);
+});
+
+?>
diff --git a/benchmark_str_pad.php b/benchmark_str_pad.php
new file mode 100644
index 0000000000000..64612216045e3
--- /dev/null
+++ b/benchmark_str_pad.php
@@ -0,0 +1,27 @@
+<?php
+
+function benchmark_str_pad(string $input, int $pad_length, string $pad_string, int $pad_type) {
+    $start = microtime(true);
+    for ($i = 0; $i < 100000; $i++) {
+        str_pad($input, $pad_length, $pad_string, $pad_type);
+    }
+    $end = microtime(true);
+    return $end - $start;
+}
+
+$short_string = 'Hello';
+$long_string = str_repeat('Hello', 100);
+
+echo "Benchmarking current str_pad implementation...\n";
+
+echo "Short string, right pad: " . benchmark_str_pad($short_string, 100, ' ', STR_PAD_RIGHT) . "s\n";
+echo "Short string, left pad: " . benchmark_str_pad($short_string, 100, ' ', STR_PAD_LEFT) . "s\n";
+echo "Short string, both pad: " . benchmark_str_pad($short_string, 100, ' ', STR_PAD_BOTH) . "s\n";
+
+echo "Long string, right pad: " . benchmark_str_pad($long_string, 1000, ' ', STR_PAD_RIGHT) . "s\n";
+echo "Long string, left pad: " . benchmark_str_pad($long_string, 1000, ' ', STR_PAD_LEFT) . "s\n";
+echo "Long string, both pad: " . benchmark_str_pad($long_string, 1000, ' ', STR_PAD_BOTH) . "s\n";
+
+echo "Short string, multi-char pad, right: " . benchmark_str_pad($short_string, 100, '-=', STR_PAD_RIGHT) . "s\n";
+echo "Short string, multi-char pad, left: " . benchmark_str_pad($short_string, 100, '-=', STR_PAD_LEFT) . "s\n";
+echo "Short string, multi-char pad, both: " . benchmark_str_pad($short_string, 100, '-=', STR_PAD_BOTH) . "s\n";
diff --git a/benchmark_str_word_count.php b/benchmark_str_word_count.php
new file mode 100644
index 0000000000000..70033f4583c76
--- /dev/null
+++ b/benchmark_str_word_count.php
@@ -0,0 +1,26 @@
+<?php
+
+function benchmark_str_word_count(string $string, int $format = 0, ?string $characters = null) {
+    $start = microtime(true);
+    for ($i = 0; $i < 100000; $i++) {
+        str_word_count($string, $format, $characters);
+    }
+    $end = microtime(true);
+    return $end - $start;
+}
+
+$short_string = 'Hello world, this is a test.';
+$long_string = str_repeat($short_string . ' ', 1000);
+
+echo "Benchmarking current str_word_count implementation...\n";
+
+echo "Short string, format 0: " . benchmark_str_word_count($short_string, 0) . "s\n";
+echo "Short string, format 1: " . benchmark_str_word_count($short_string, 1) . "s\n";
+echo "Short string, format 2: " . benchmark_str_word_count($short_string, 2) . "s\n";
+
+echo "Long string, format 0: " . benchmark_str_word_count($long_string, 0) . "s\n";
+echo "Long string, format 1: " . benchmark_str_word_count($long_string, 1) . "s\n";
+echo "Long string, format 2: " . benchmark_str_word_count($long_string, 2) . "s\n";
+
+echo "Short string with extra chars, format 0: " . benchmark_str_word_count($short_string, 0, '.,') . "s\n";
+echo "Long string with extra chars, format 0: " . benchmark_str_word_count($long_string, 0, '.,') . "s\n";
diff --git a/benchmark_strcmp.php b/benchmark_strcmp.php
new file mode 100644
index 0000000000000..73ca7e900aca5
--- /dev/null
+++ b/benchmark_strcmp.php
@@ -0,0 +1,50 @@
+<?php
+
+function benchmark($name, $func) {
+    // strcmp is extremely fast, so a very high iteration count is needed for meaningful results.
+    $iterations = 2000000;
+    $start = microtime(true);
+    for ($i = 0; $i < $iterations; $i++) {
+        $func();
+    }
+    $end = microtime(true);
+    echo str_pad($name, 45) . ": " . number_format($end - $start, 6) . "s\n";
+}
+
+echo "Benchmarking current strcmp implementation...\n";
+
+$long_string1 = str_repeat("abcdefghijklmnopqrstuvwxyz", 10); // 260 chars
+$long_string2 = str_repeat("abcdefghijklmnopqrstuvwxyz", 10); // 260 chars, same content
+$long_string_prefix = substr($long_string1, 0, -1); // 259 chars
+$long_string_diff_start = "b" . substr($long_string1, 1);
+$long_string_diff_end = substr($long_string1, 0, -1) . "A";
+
+
+// ===== TEST CASES =====
+
+// Case 1: Equal short strings
+benchmark("Equal short strings", function() {
+    strcmp("hello world", "hello world");
+});
+
+// Case 2: Equal long strings
+benchmark("Equal long strings", function() use ($long_string1, $long_string2) {
+    strcmp($long_string1, $long_string2);
+});
+
+// Case 3: Difference at beginning (should be very fast)
+benchmark("Difference at beginning", function() use ($long_string1, $long_string_diff_start) {
+    strcmp($long_string1, $long_string_diff_start);
+});
+
+// Case 4: Difference at end (should be slow)
+benchmark("Difference at end", function() use ($long_string1, $long_string_diff_end) {
+    strcmp($long_string1, $long_string_diff_end);
+});
+
+// Case 5: One string is a prefix of the other
+benchmark("Prefix comparison", function() use ($long_string1, $long_string_prefix) {
+    strcmp($long_string1, $long_string_prefix);
+});
+
+?>
diff --git a/benchmark_strstr.php b/benchmark_strstr.php
new file mode 100644
index 0000000000000..ce361dc51b5f2
--- /dev/null
+++ b/benchmark_strstr.php
@@ -0,0 +1,23 @@
+<?php
+
+function benchmark_strstr(string $haystack, string $needle) {
+    $start = microtime(true);
+    for ($i = 0; $i < 100000; $i++) {
+        strstr($haystack, $needle);
+    }
+    $end = microtime(true);
+    return $end - $start;
+}
+
+$long_haystack = str_repeat('abcdefghijklmnopqrstuvwxyz', 1000);
+$short_needle_front = 'abc';
+$short_needle_middle = 'mno';
+$short_needle_end = 'xyz';
+$not_found_needle = '123';
+
+echo "Benchmarking current strstr implementation...\n";
+
+echo "Long haystack, short needle (front): " . benchmark_strstr($long_haystack, $short_needle_front) . "s\n";
+echo "Long haystack, short needle (middle): " . benchmark_strstr($long_haystack, $short_needle_middle) . "s\n";
+echo "Long haystack, short needle (end): " . benchmark_strstr($long_haystack, $short_needle_end) . "s\n";
+echo "Long haystack, needle not found: " . benchmark_strstr($long_haystack, $not_found_needle) . "s\n";
diff --git a/benchmark_strtolower.php b/benchmark_strtolower.php
new file mode 100644
index 0000000000000..2ab406673deec
--- /dev/null
+++ b/benchmark_strtolower.php
@@ -0,0 +1,26 @@
+<?php
+
+function benchmark_strtolower(string $str) {
+    $start = microtime(true);
+    for ($i = 0; $i < 100000; $i++) {
+        strtolower($str);
+    }
+    $end = microtime(true);
+    return $end - $start;
+}
+
+$short_ascii = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+$long_ascii = str_repeat($short_ascii, 1000);
+$short_mixed = 'aBcDeFgHiJkLmNoPqRsTuVwXyZ';
+$long_mixed = str_repeat($short_mixed, 1000);
+$short_lower = 'abcdefghijklmnopqrstuvwxyz';
+$long_lower = str_repeat($short_lower, 1000);
+
+echo "Benchmarking current strtolower implementation...\n";
+
+echo "Short ASCII string: " . benchmark_strtolower($short_ascii) . "s\n";
+echo "Long ASCII string: " . benchmark_strtolower($long_ascii) . "s\n";
+echo "Short mixed-case string: " . benchmark_strtolower($short_mixed) . "s\n";
+echo "Long mixed-case string: " . benchmark_strtolower($long_mixed) . "s\n";
+echo "Short lowercase string: " . benchmark_strtolower($short_lower) . "s\n";
+echo "Long lowercase string: " . benchmark_strtolower($long_lower) . "s\n";
diff --git a/ext/standard/array.c b/ext/standard/array.c
index 981bda9a22254..126b15119fd10 100644
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -3116,10 +3116,12 @@ PHP_FUNCTION(range)
 
 			RANGE_CHECK_DOUBLE_INIT_ARRAY(start_double, end_double, step_double);
 
+			element = start_double;
 			ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
-				for (i = 0, element = start_double; i < size && element >= end_double; ++i, element = start_double - (i * step_double)) {
+				for (i = 0; i < size; i++) {
 					ZEND_HASH_FILL_SET_DOUBLE(element);
 					ZEND_HASH_FILL_NEXT();
+					element -= step_double;
 				}
 			} ZEND_HASH_FILL_END();
 		} else if (end_double > start_double) { /* Increasing float range */
@@ -3132,10 +3134,12 @@ PHP_FUNCTION(range)
 
 			RANGE_CHECK_DOUBLE_INIT_ARRAY(end_double, start_double, step_double);
 
+			element = start_double;
 			ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
-				for (i = 0, element = start_double; i < size && element <= end_double; ++i, element = start_double + (i * step_double)) {
+				for (i = 0; i < size; i++) {
 					ZEND_HASH_FILL_SET_DOUBLE(element);
 					ZEND_HASH_FILL_NEXT();
+					element += step_double;
 				}
 			} ZEND_HASH_FILL_END();
 		} else {
@@ -3146,8 +3150,9 @@ PHP_FUNCTION(range)
 	} else {
 		ZEND_ASSERT(start_type == IS_LONG && end_type == IS_LONG && !is_step_double);
 		/* unsigned_step is a zend_ulong so that comparisons to it don't overflow, i.e. low - high < lstep */
-		zend_ulong unsigned_step= (zend_ulong)step;
+		zend_ulong unsigned_step = (zend_ulong)step;
 		uint32_t i, size;
+		zend_long current_val;
 
 		/* Decreasing int range */
 		if (start_long > end_long) {
@@ -3157,10 +3162,12 @@ PHP_FUNCTION(range)
 
 			RANGE_CHECK_LONG_INIT_ARRAY(start_long, end_long, unsigned_step);
 
+			current_val = start_long;
 			ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
 				for (i = 0; i < size; ++i) {
-					ZEND_HASH_FILL_SET_LONG(start_long - (i * unsigned_step));
+					ZEND_HASH_FILL_SET_LONG(current_val);
 					ZEND_HASH_FILL_NEXT();
+					current_val -= unsigned_step;
 				}
 			} ZEND_HASH_FILL_END();
 		} else if (end_long > start_long) { /* Increasing int range */
@@ -3173,10 +3180,12 @@ PHP_FUNCTION(range)
 
 			RANGE_CHECK_LONG_INIT_ARRAY(end_long, start_long, unsigned_step);
 
+			current_val = start_long;
 			ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) {
 				for (i = 0; i < size; ++i) {
-					ZEND_HASH_FILL_SET_LONG(start_long + (i * unsigned_step));
+					ZEND_HASH_FILL_SET_LONG(current_val);
 					ZEND_HASH_FILL_NEXT();
+					current_val += unsigned_step;
 				}
 			} ZEND_HASH_FILL_END();
 		} else {
@@ -7083,7 +7092,7 @@ PHP_FUNCTION(array_combine)
 	HashTable *values, *keys;
 	uint32_t pos_values = 0;
 	zval *entry_keys, *entry_values;
-	int num_keys, num_values;
+	uint32_t num_keys, num_values;
 
 	ZEND_PARSE_PARAMETERS_START(2, 2)
 		Z_PARAM_ARRAY_HT(keys)
@@ -7103,29 +7112,48 @@ PHP_FUNCTION(array_combine)
 	}
 
 	array_init_size(return_value, num_keys);
-	ZEND_HASH_FOREACH_VAL(keys, entry_keys) {
-		while (1) {
-			if (pos_values >= values->nNumUsed) {
-				break;
+
+	/* Fast path for packed arrays without holes */
+	if (HT_IS_PACKED(keys) && HT_IS_WITHOUT_HOLES(keys) &&
+	    HT_IS_PACKED(values) && HT_IS_WITHOUT_HOLES(values)) {
+		uint32_t i;
+		for (i = 0; i < num_keys; i++) {
+			entry_keys = &keys->arPacked[i];
+			entry_values = &values->arPacked[i];
+
+			if (Z_TYPE_P(entry_keys) == IS_LONG) {
+				zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry_keys), entry_values);
+			} else {
+				zend_string *tmp_key;
+				zend_string *key = zval_get_tmp_string(entry_keys, &tmp_key);
+				zend_symtable_update(Z_ARRVAL_P(return_value), key, entry_values);
+				zend_tmp_string_release(tmp_key);
 			}
-			entry_values = ZEND_HASH_ELEMENT(values, pos_values);
-			if (Z_TYPE_P(entry_values) != IS_UNDEF) {
-				if (Z_TYPE_P(entry_keys) == IS_LONG) {
-					entry_values = zend_hash_index_update(Z_ARRVAL_P(return_value),
-						Z_LVAL_P(entry_keys), entry_values);
-				} else {
-					zend_string *tmp_key;
-					zend_string *key = zval_get_tmp_string(entry_keys, &tmp_key);
-					entry_values = zend_symtable_update(Z_ARRVAL_P(return_value),
-						key, entry_values);
-					zend_tmp_string_release(tmp_key);
+		}
+	} else {
+		ZEND_HASH_FOREACH_VAL(keys, entry_keys) {
+			while (1) {
+				if (pos_values >= values->nNumUsed) {
+					break;
+				}
+				entry_values = ZEND_HASH_ELEMENT(values, pos_values);
+				if (Z_TYPE_P(entry_values) != IS_UNDEF) {
+					if (Z_TYPE_P(entry_keys) == IS_LONG) {
+						zend_hash_index_update(Z_ARRVAL_P(return_value),
+							Z_LVAL_P(entry_keys), entry_values);
+					} else {
+						zend_string *tmp_key;
+						zend_string *key = zval_get_tmp_string(entry_keys, &tmp_key);
+						zend_symtable_update(Z_ARRVAL_P(return_value),
+							key, entry_values);
+						zend_tmp_string_release(tmp_key);
+					}
+					pos_values++;
+					break;
 				}
-				zval_add_ref(entry_values);
 				pos_values++;
-				break;
 			}
-			pos_values++;
-		}
-	} ZEND_HASH_FOREACH_END();
+		} ZEND_HASH_FOREACH_END();
+	}
 }
 /* }}} */
diff --git a/ext/standard/string.c b/ext/standard/string.c
index a5acb28ddb3bc..a5c2886930ee2 100644
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -5805,16 +5805,42 @@ PHP_FUNCTION(str_pad)
 	}
 
 	/* First we pad on the left. */
-	for (i = 0; i < left_pad; i++)
-		ZSTR_VAL(result)[ZSTR_LEN(result)++] = pad_str[i % pad_str_len];
+	if (left_pad > 0) {
+		if (pad_str_len == 1) {
+			memset(ZSTR_VAL(result), *pad_str, left_pad);
+		} else {
+			char *p = ZSTR_VAL(result);
+			for (i = 0; i < left_pad / pad_str_len; i++) {
+				memcpy(p, pad_str, pad_str_len);
+				p += pad_str_len;
+			}
+			if (left_pad % pad_str_len) {
+				memcpy(p, pad_str, left_pad % pad_str_len);
+			}
+		}
+		ZSTR_LEN(result) += left_pad;
+	}
 
 	/* Then we copy the input string. */
 	memcpy(ZSTR_VAL(result) + ZSTR_LEN(result), ZSTR_VAL(input), ZSTR_LEN(input));
 	ZSTR_LEN(result) += ZSTR_LEN(input);
 
 	/* Finally, we pad on the right. */
-	for (i = 0; i < right_pad; i++)
-		ZSTR_VAL(result)[ZSTR_LEN(result)++] = pad_str[i % pad_str_len];
+	if (right_pad > 0) {
+		if (pad_str_len == 1) {
+			memset(ZSTR_VAL(result) + ZSTR_LEN(result), *pad_str, right_pad);
+		} else {
+			char *p = ZSTR_VAL(result) + ZSTR_LEN(result);
+			for (i = 0; i < right_pad / pad_str_len; i++) {
+				memcpy(p, pad_str, pad_str_len);
+				p += pad_str_len;
+			}
+			if (right_pad % pad_str_len) {
+				memcpy(p, pad_str, right_pad % pad_str_len);
+			}
+		}
+		ZSTR_LEN(result) += right_pad;
+	}
 
 	ZSTR_VAL(result)[ZSTR_LEN(result)] = '\0';