diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c
index d0aaccec7ce2c..c55a11c7db437 100644
--- a/Zend/Optimizer/compact_literals.c
+++ b/Zend/Optimizer/compact_literals.c
@@ -734,12 +734,17 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
 				case ZEND_SEND_VAR_NO_REF_EX:
 				case ZEND_SEND_REF:
 				case ZEND_SEND_FUNC_ARG:
+				case ZEND_SEND_PLACEHOLDER:
 				case ZEND_CHECK_FUNC_ARG:
 					if (opline->op2_type == IS_CONST) {
 						opline->result.num = cache_size;
 						cache_size += 2 * sizeof(void *);
 					}
 					break;
+				case ZEND_CALLABLE_CONVERT_PARTIAL:
+					opline->op1.num = cache_size;
+					cache_size += 2 * sizeof(void *);
+					break;
 			}
 			opline++;
 		}
diff --git a/Zend/Optimizer/optimize_func_calls.c b/Zend/Optimizer/optimize_func_calls.c
index 8b29f47c94976..39b62dc4d7af5 100644
--- a/Zend/Optimizer/optimize_func_calls.c
+++ b/Zend/Optimizer/optimize_func_calls.c
@@ -193,6 +193,7 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 			case ZEND_DO_UCALL:
 			case ZEND_DO_FCALL_BY_NAME:
 			case ZEND_CALLABLE_CONVERT:
+			case ZEND_CALLABLE_CONVERT_PARTIAL:
 				call--;
 				if (call_stack[call].func && call_stack[call].opline) {
 					zend_op *fcall = call_stack[call].opline;
@@ -225,13 +226,14 @@ void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx)
 					 * At this point we also know whether or not the result of
 					 * the DO opcode is used, allowing to optimize calls to
 					 * ZEND_ACC_NODISCARD functions. */
-					if (opline->opcode != ZEND_CALLABLE_CONVERT) {
+					if (opline->opcode != ZEND_CALLABLE_CONVERT && opline->opcode != ZEND_CALLABLE_CONVERT_PARTIAL) {
 						opline->opcode = zend_get_call_op(fcall, call_stack[call].func, !RESULT_UNUSED(opline));
 					}
 
 					if ((ZEND_OPTIMIZER_PASS_16 & ctx->optimization_level)
 							&& call_stack[call].try_inline
-							&& opline->opcode != ZEND_CALLABLE_CONVERT) {
+							&& opline->opcode != ZEND_CALLABLE_CONVERT
+							&& opline->opcode != ZEND_CALLABLE_CONVERT_PARTIAL) {
 						zend_try_inline_call(op_array, fcall, opline, call_stack[call].func);
 					}
 				}
diff --git a/Zend/Optimizer/zend_call_graph.c b/Zend/Optimizer/zend_call_graph.c
index 8a2f8ea2a7e1a..26dfdaefe1be1 100644
--- a/Zend/Optimizer/zend_call_graph.c
+++ b/Zend/Optimizer/zend_call_graph.c
@@ -128,6 +128,7 @@ ZEND_API void zend_analyze_calls(zend_arena **arena, zend_script *script, uint32
 			case ZEND_DO_UCALL:
 			case ZEND_DO_FCALL_BY_NAME:
 			case ZEND_CALLABLE_CONVERT:
+			case ZEND_CALLABLE_CONVERT_PARTIAL:
 				func_info->flags |= ZEND_FUNC_HAS_CALLS;
 				if (call_info) {
 					call_info->caller_call_opline = opline;
@@ -144,11 +145,15 @@ ZEND_API void zend_analyze_calls(zend_arena **arena, zend_script *script, uint32
 			case ZEND_SEND_VAR_NO_REF:
 			case ZEND_SEND_VAR_NO_REF_EX:
 			case ZEND_SEND_USER:
+			case ZEND_SEND_PLACEHOLDER:
 				if (call_info) {
 					if (opline->op2_type == IS_CONST) {
 						call_info->named_args = 1;
 						break;
 					}
+					if (opline->opcode == ZEND_SEND_PLACEHOLDER && opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+						break;
+					}
 
 					uint32_t num = opline->op2.num;
 					if (num > 0) {
diff --git a/Zend/Optimizer/zend_inference.c b/Zend/Optimizer/zend_inference.c
index 62e04cb0e306b..591c99603a09f 100644
--- a/Zend/Optimizer/zend_inference.c
+++ b/Zend/Optimizer/zend_inference.c
@@ -3905,6 +3905,7 @@ static zend_always_inline zend_result _zend_update_type_info(
 			}
 			break;
 		case ZEND_CALLABLE_CONVERT:
+		case ZEND_CALLABLE_CONVERT_PARTIAL:
 			UPDATE_SSA_TYPE(MAY_BE_OBJECT | MAY_BE_RC1 | MAY_BE_RCN, ssa_op->result_def);
 			UPDATE_SSA_OBJ_TYPE(zend_ce_closure, /* is_instanceof */ false, ssa_op->result_def);
 			break;
diff --git a/Zend/tests/partial_application/attributes_001.phpt b/Zend/tests/partial_application/attributes_001.phpt
new file mode 100644
index 0000000000000..05b25cd5ce054
--- /dev/null
+++ b/Zend/tests/partial_application/attributes_001.phpt
@@ -0,0 +1,92 @@
+--TEST--
+Closure application copies attributes
+--XFAIL--
+Only NoDiscard and SensitiveParameter are copied
+--FILE--
+<?php
+
+#[Attribute]
+class Test {}
+
+#[NoDiscard]
+function f($a, #[SensitiveParameter] $b, #[Test] ...$c) {
+}
+
+function dump_attributes($function) {
+    echo "Function attributes:\n";
+    $r = new ReflectionFunction($function);
+    var_dump($r->getAttributes());
+
+    foreach ($r->getParameters() as $i => $p) {
+        echo "Parameter $i:\n";
+        var_dump($p->getAttributes());
+    }
+}
+
+dump_attributes('f');
+
+$f = f(1, ?, ?, ...);
+
+dump_attributes($f);
+
+?>
+--EXPECTF--
+Function attributes:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(9) "NoDiscard"
+  }
+}
+Parameter 0:
+array(0) {
+}
+Parameter 1:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(18) "SensitiveParameter"
+  }
+}
+Parameter 2:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(4) "Test"
+  }
+}
+Function attributes:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(9) "NoDiscard"
+  }
+}
+Parameter 0:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(18) "SensitiveParameter"
+  }
+}
+Parameter 1:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(4) "Test"
+  }
+}
+Parameter 2:
+array(1) {
+  [0]=>
+  object(ReflectionAttribute)#%d (1) {
+    ["name"]=>
+    string(4) "Test"
+  }
+}
diff --git a/Zend/tests/partial_application/attributes_002.phpt b/Zend/tests/partial_application/attributes_002.phpt
new file mode 100644
index 0000000000000..d2aaf35be4529
--- /dev/null
+++ b/Zend/tests/partial_application/attributes_002.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Closure application preserves #[SensitiveParameter]
+--FILE--
+<?php
+
+function f($a, #[SensitiveParameter] $b, $c) {
+    throw new Exception();
+}
+
+echo "# During partial application:\n";
+
+try {
+    $f = f(1, 'sensitive');
+} catch (Error $e) {
+    echo $e, "\n\n";
+}
+
+echo "# In trampoline:\n";
+
+try {
+    $f = f(1, ?, ?)('sensitive');
+} catch (Error $e) {
+    echo $e, "\n\n";
+}
+
+echo "# In execution:\n";
+
+try {
+    $f = f(1, ?, ?)('sensitive', 3);
+} catch (Exception $e) {
+    echo $e, "\n";
+}
+
+?>
+--EXPECTF--
+# During partial application:
+ArgumentCountError: Too few arguments to function f(), 2 passed in %s on line %d and exactly 3 expected in %s:%d
+Stack trace:
+#0 %s(%d): f(1, Object(SensitiveParameterValue))
+#1 {main}
+
+# In trampoline:
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 1 passed in %s on line %d and exactly 2 expected in %s:%d
+Stack trace:
+#0 %s(%d): {closure:%s}(Object(SensitiveParameterValue))
+#1 {main}
+
+# In execution:
+Exception in %s:%d
+Stack trace:
+#0 %s(%d): f(1, Object(SensitiveParameterValue), 3)
+#1 %s(%d): {closure:%s}(Object(SensitiveParameterValue), 3)
+#2 {main}
diff --git a/Zend/tests/partial_application/attributes_003.phpt b/Zend/tests/partial_application/attributes_003.phpt
new file mode 100644
index 0000000000000..2fb9a309f69d3
--- /dev/null
+++ b/Zend/tests/partial_application/attributes_003.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application preserves #[NoDiscard]
+--FILE--
+<?php
+
+#[NoDiscard] function f($a) {
+}
+
+$f = f(?);
+$f(1);
+
+(void) $f(1);
+
+?>
+--EXPECTF--
+Warning: The return value of function {closure:%s}() should either be used or intentionally ignored by casting it as (void) in %s on line 7
diff --git a/Zend/tests/partial_application/clone.phpt b/Zend/tests/partial_application/clone.phpt
new file mode 100644
index 0000000000000..1acfaa34aafbe
--- /dev/null
+++ b/Zend/tests/partial_application/clone.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Closure application clone
+--FILE--
+<?php
+
+class C {
+    public function __construct(
+        public mixed $a,
+        public mixed $b,
+    ) { }
+}
+
+$clone = clone(?);
+var_dump($clone(new C(1, 2)));
+
+$clone = clone(...);
+var_dump($clone(new C(3, 4)));
+
+$clone = clone(new C(5, 6), ?);
+var_dump($clone(['a' => 7]));
+
+$clone = clone(?, ['a' => 8]);
+var_dump($clone(new C(9, 10)));
+
+?>
+--EXPECTF--
+object(C)#%d (2) {
+  ["a"]=>
+  int(1)
+  ["b"]=>
+  int(2)
+}
+object(C)#%d (2) {
+  ["a"]=>
+  int(3)
+  ["b"]=>
+  int(4)
+}
+object(C)#%d (2) {
+  ["a"]=>
+  int(7)
+  ["b"]=>
+  int(6)
+}
+object(C)#%d (2) {
+  ["a"]=>
+  int(8)
+  ["b"]=>
+  int(10)
+}
diff --git a/Zend/tests/partial_application/compile_errors_001.phpt b/Zend/tests/partial_application/compile_errors_001.phpt
new file mode 100644
index 0000000000000..5a73f7082a831
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_001.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: multiple ...
+--FILE--
+<?php
+foo(..., ...);
+?>
+--EXPECTF--
+Fatal error: Variadic placeholder may only appear once in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_002.phpt b/Zend/tests/partial_application/compile_errors_002.phpt
new file mode 100644
index 0000000000000..6af96c87602e7
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_002.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: ... must be last
+--FILE--
+<?php
+foo(..., ?);
+?>
+--EXPECTF--
+Fatal error: Variadic placeholder must be last in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_003.phpt b/Zend/tests/partial_application/compile_errors_003.phpt
new file mode 100644
index 0000000000000..8719f5d6e7dd2
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_003.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: named arguments must come after placeholder
+--FILE--
+<?php
+foo(n: 5, ?);
+?>
+--EXPECTF--
+Fatal error: Cannot use positional argument after named argument in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_004.phpt b/Zend/tests/partial_application/compile_errors_004.phpt
new file mode 100644
index 0000000000000..997d4bb11db3d
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_004.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: named arguments must come before variadic placeholder
+--FILE--
+<?php
+foo(..., n: 5);
+?>
+--EXPECTF--
+Fatal error: Variadic placeholder must be last in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_005.phpt b/Zend/tests/partial_application/compile_errors_005.phpt
new file mode 100644
index 0000000000000..7d890fe455b9d
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_005.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: follow variadic with un-named arg
+--FILE--
+<?php
+foo(..., $a);
+?>
+--EXPECTF--
+Fatal error: Variadic placeholder must be last in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_006.phpt b/Zend/tests/partial_application/compile_errors_006.phpt
new file mode 100644
index 0000000000000..2ad8b9df4ec9a
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_006.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: mix application with unpack (placeholder after)
+--FILE--
+<?php
+foo(...["foo" => "bar"], ...);
+?>
+--EXPECTF--
+Fatal error: Cannot combine partial application and unpacking in %s on line %d
diff --git a/Zend/tests/partial_application/compile_errors_007.phpt b/Zend/tests/partial_application/compile_errors_007.phpt
new file mode 100644
index 0000000000000..c2cc0e04aea22
--- /dev/null
+++ b/Zend/tests/partial_application/compile_errors_007.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Closure application compile errors: mix application with unpack
+--FILE--
+<?php
+foo(...["foo" => "bar"], ...);
+?>
+--EXPECTF--
+Fatal error: Cannot combine partial application and unpacking %s on line %d
diff --git a/Zend/tests/partial_application/errors_001.phpt b/Zend/tests/partial_application/errors_001.phpt
new file mode 100644
index 0000000000000..6e9eb3faf842d
--- /dev/null
+++ b/Zend/tests/partial_application/errors_001.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Closure application errors: placeholder count errors
+--FILE--
+<?php
+function foo($a, $b, $c) {
+
+}
+
+try {
+    foo(?);
+} catch (Error $ex) {
+    printf("%s\n", $ex->getMessage());
+}
+
+try {
+    foo(?, ?, ?, ?);
+} catch (Error $ex) {
+    printf("%s\n", $ex->getMessage());
+}
+
+try {
+    property_exists(?);
+} catch (Error $ex) {
+    printf("%s\n", $ex->getMessage());
+}
+
+try {
+    usleep(?, ?);
+} catch (Error $ex) {
+    printf("%s\n", $ex->getMessage());
+}
+?>
+--EXPECT--
+not enough arguments or placeholders for application of foo, 1 given and exactly 3 expected
+too many arguments or placeholders for application of foo, 4 given and a maximum of 3 expected
+not enough arguments or placeholders for application of property_exists, 1 given and exactly 2 expected
+too many arguments or placeholders for application of usleep, 2 given and a maximum of 1 expected
diff --git a/Zend/tests/partial_application/errors_002.phpt b/Zend/tests/partial_application/errors_002.phpt
new file mode 100644
index 0000000000000..fd6ede5a3c3ab
--- /dev/null
+++ b/Zend/tests/partial_application/errors_002.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application errors: named parameter overwrites placeholder
+--FILE--
+<?php
+function foo($a) {
+
+}
+
+try {
+    foo(?, a: 1);
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+?>
+--EXPECT--
+Error: Named parameter $a overwrites previous placeholder
diff --git a/Zend/tests/partial_application/errors_003.phpt b/Zend/tests/partial_application/errors_003.phpt
new file mode 100644
index 0000000000000..2ed47d8b5451c
--- /dev/null
+++ b/Zend/tests/partial_application/errors_003.phpt
@@ -0,0 +1,77 @@
+--TEST--
+Closure application errors: missing parameters
+--FILE--
+<?php
+function foo($a, ...$b) {
+
+}
+
+function bar($a, $b, $c) {}
+
+$foo = foo(?);
+
+try {
+    $foo();
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$foo = foo(?, ?);
+
+try {
+    $foo(1);
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$bar = bar(?, ?, ...);
+
+try {
+    $bar(1);
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+class Foo {
+    public function bar($a, ...$b) {}
+}
+
+$foo = new Foo;
+
+$bar = $foo->bar(?);
+
+try {
+    $bar();
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$repeat = str_repeat('a', ...);
+
+try {
+    $repeat();
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$usleep = usleep(?);
+
+try {
+    $usleep();
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+try {
+    $usleep(1, 2);
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+?>
+--EXPECTF--
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 0 passed in %s on line %d and exactly 1 expected
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 1 passed in %s on line %d and exactly 2 expected
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 1 passed in %s on line %d and exactly 3 expected
+ArgumentCountError: Too few arguments to function Foo::{closure:%s:%d}(), 0 passed in %s on line %d and exactly 1 expected
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 0 passed in %s on line %d and exactly 1 expected
+ArgumentCountError: Too few arguments to function {closure:%s:%d}(), 0 passed in %s on line %d and exactly 1 expected
diff --git a/Zend/tests/partial_application/export_001.phpt b/Zend/tests/partial_application/export_001.phpt
new file mode 100644
index 0000000000000..2f7f7dd2d656d
--- /dev/null
+++ b/Zend/tests/partial_application/export_001.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application ast export
+--INI--
+assert.exception=1
+--FILE--
+<?php
+try {
+    assert(0 && foo(?) && foo(new stdClass, ...));
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+?>
+--EXPECT--
+AssertionError: assert(0 && foo(?) && foo(new stdClass(), ...))
diff --git a/Zend/tests/partial_application/extra_collect_001.phpt b/Zend/tests/partial_application/extra_collect_001.phpt
new file mode 100644
index 0000000000000..6f12a6d2f8b42
--- /dev/null
+++ b/Zend/tests/partial_application/extra_collect_001.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Closure application named parameters: extra collection
+--FILE--
+<?php
+function foo(...$args) {
+    var_dump($args);
+}
+
+$foo = foo(foo: "foo", ...);
+
+$bar = $foo(bar: "bar", ...);
+
+$baz = $bar(baz: "baz", ...);
+
+$baz();
+
+$foo = foo(...);
+
+$bar = $foo(bar: "bar", ...);
+
+$baz = $bar(baz: "baz", ...);
+
+$baz();
+
+$foo = foo(foo: "foo", ...);
+
+$foo(bar: "bar");
+?>
+--EXPECT--
+array(3) {
+  ["foo"]=>
+  string(3) "foo"
+  ["bar"]=>
+  string(3) "bar"
+  ["baz"]=>
+  string(3) "baz"
+}
+array(2) {
+  ["bar"]=>
+  string(3) "bar"
+  ["baz"]=>
+  string(3) "baz"
+}
+array(2) {
+  ["foo"]=>
+  string(3) "foo"
+  ["bar"]=>
+  string(3) "bar"
+}
diff --git a/Zend/tests/partial_application/fuzz_001.phpt b/Zend/tests/partial_application/fuzz_001.phpt
new file mode 100644
index 0000000000000..4692dc9ea45e4
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_001.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Closure application fuzz 001
+--FILE--
+<?php
+$closure = function($a, $b) {};
+
+echo (string) new ReflectionFunction($closure(1, ?));
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 4 - 4
+
+  - Bound Variables [2] {
+      Variable #0 [ $a ]
+      Variable #1 [ $fn ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $b ]
+  }
+}
diff --git a/Zend/tests/partial_application/fuzz_002.phpt b/Zend/tests/partial_application/fuzz_002.phpt
new file mode 100644
index 0000000000000..685cb706e69bb
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_002.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Closure application fuzz 002
+--FILE--
+<?php
+class Foo {
+    static function __callStatic($name, $args) {}
+}
+Foo::method(?);
+
+echo "OK";
+?>
+--EXPECTF--
+OK
diff --git a/Zend/tests/partial_application/fuzz_003.phpt b/Zend/tests/partial_application/fuzz_003.phpt
new file mode 100644
index 0000000000000..c106b5db5ea8e
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_003.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Closure application fuzz 003
+--FILE--
+<?php
+class Foo {
+    function __call($name, $args) {
+        var_dump($args);
+    }
+}
+$foo = new Foo;
+$bar = $foo->method(1,...);
+$bar(2);
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
diff --git a/Zend/tests/partial_application/fuzz_004.phpt b/Zend/tests/partial_application/fuzz_004.phpt
new file mode 100644
index 0000000000000..002099ba59aab
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_004.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Closure application fuzz 004
+--FILE--
+<?php
+function foo($a, $b) {
+    return $a + $b;
+}
+
+$foo = foo(b: 10, ...);
+
+try {
+    $foo->__invoke(UNDEFINED);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+Undefined constant "UNDEFINED"
diff --git a/Zend/tests/partial_application/fuzz_005.phpt b/Zend/tests/partial_application/fuzz_005.phpt
new file mode 100644
index 0000000000000..8c107363f9a98
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_005.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application fuzz 005
+--FILE--
+<?php
+
+function foo(int $day = 1, int $month = 1, int $yearh = 1, int $year = 2005) {
+}
+
+$foo = foo(month: 12, ...);
+
+$bar = $foo(year: 2016, ...);
+
+?>
+==DONE==
+--EXPECT--
+==DONE==
diff --git a/Zend/tests/partial_application/fuzz_006.phpt b/Zend/tests/partial_application/fuzz_006.phpt
new file mode 100644
index 0000000000000..a7b94b34d4094
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_006.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application fuzz 006
+--FILE--
+<?php
+
+function foo(int $day = 1, int $month = 1, int $year = 2005) {
+    var_dump($day);
+}
+
+$foo = foo(month: 12, ...);
+
+$foo(year: 2025);
+
+?>
+--EXPECT--
+int(1)
diff --git a/Zend/tests/partial_application/fuzz_007.phpt b/Zend/tests/partial_application/fuzz_007.phpt
new file mode 100644
index 0000000000000..705e7afbd190a
--- /dev/null
+++ b/Zend/tests/partial_application/fuzz_007.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Closure application fuzz 007
+--FILE--
+<?php
+
+function foo(int $day = 1, int $month = UNDEFINED, int $year = 2005) {
+}
+
+$foo = foo(year: 2006, ...);
+
+try {
+    $foo(2);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+Undefined constant "UNDEFINED"
diff --git a/Zend/tests/partial_application/invokable.phpt b/Zend/tests/partial_application/invokable.phpt
new file mode 100644
index 0000000000000..8c9f74d271cc7
--- /dev/null
+++ b/Zend/tests/partial_application/invokable.phpt
@@ -0,0 +1,51 @@
+--TEST--
+Closure application invokable
+--FILE--
+<?php
+
+class C {
+    public function __invoke(int $a, object $b): C {
+        var_dump($a, $b);
+        return $this;
+    }
+}
+
+$c = new C();
+$f = $c(?, ...);
+
+echo (string) new ReflectionFunction($f), "\n";
+
+$f = $c(?, new stdClass);
+
+echo (string) new ReflectionFunction($f), "\n";
+
+$f(1);
+
+?>
+--EXPECTF--
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 11 - 11
+
+  - Parameters [2] {
+    Parameter #0 [ <required> int $a ]
+    Parameter #1 [ <required> object $b ]
+  }
+  - Return [ C ]
+}
+
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 15 - 15
+
+  - Bound Variables [1] {
+      Variable #0 [ $b ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <required> int $a ]
+  }
+  - Return [ C ]
+}
+
+int(1)
+object(stdClass)#%d (0) {
+}
diff --git a/Zend/tests/partial_application/jit_001.phpt b/Zend/tests/partial_application/jit_001.phpt
new file mode 100644
index 0000000000000..c043e2420c695
--- /dev/null
+++ b/Zend/tests/partial_application/jit_001.phpt
@@ -0,0 +1,9 @@
+--TEST--
+Closure application JIT 001
+--FILE--
+<?php
+(function ($a,$b) { var_dump($a, $b); })(1, ...)(2);
+?>
+--EXPECT--
+int(1)
+int(2)
diff --git a/Zend/tests/partial_application/magic_001.phpt b/Zend/tests/partial_application/magic_001.phpt
new file mode 100644
index 0000000000000..73c0b39d2a824
--- /dev/null
+++ b/Zend/tests/partial_application/magic_001.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Closure application magic: __call
+--XFAIL--
+TODO: extra args rules
+--FILE--
+<?php
+class Foo {
+    public function __call($method, $args) {
+        printf("%s::%s\n", __CLASS__, $method);
+
+        var_dump(...$args);
+    }
+}
+
+$foo = new Foo;
+
+$bar = $foo->method(?);
+
+echo (string) new ReflectionFunction($bar);
+
+try {
+    $bar();
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+try {
+    $bar(1, 2);
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$bar(1);
+
+$bar = $foo->method(?, ...);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(10);
+
+$bar = $foo->method(new Foo, ...);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(100);
+?>
+--EXPECTF--
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s 12 - 12
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $args0 ]
+  }
+}
+ArgumentCountError: Too few arguments to function Foo::{closure:%s:%d}(), 0 passed in %s on line %d and exactly 1 expected
+Foo::method
+int(1)
+Foo::method
+int(1)
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s 30 - 30
+
+  - Parameters [2] {
+    Parameter #0 [ <required> $args0 ]
+    Parameter #1 [ <optional> ...$args ]
+  }
+}
+Foo::method
+int(10)
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s 36 - 36
+
+  - Bound Variables [1] {
+      Variable #0 [ $args0 ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> ...$args ]
+  }
+}
+Foo::method
+object(Foo)#%d (0) {
+}
+int(100)
diff --git a/Zend/tests/partial_application/magic_002.phpt b/Zend/tests/partial_application/magic_002.phpt
new file mode 100644
index 0000000000000..3343a348a1500
--- /dev/null
+++ b/Zend/tests/partial_application/magic_002.phpt
@@ -0,0 +1,65 @@
+--TEST--
+Closure application magic: __callStatic
+--FILE--
+<?php
+class Foo {
+    public static function __callStatic($method, $args) {
+        printf("%s::%s\n", __CLASS__, $method);
+
+        var_dump(...$args);
+    }
+}
+
+$bar = Foo::method(?);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(1);
+
+$bar = Foo::method(?, ...);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(10);
+
+$bar = Foo::method(new Foo,...);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(100);
+?>
+--EXPECTF--
+Closure [ <user> static public method {closure:%s:%d} ] {
+  @@ %s 10 - 10
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $args0 ]
+  }
+}
+Foo::method
+int(1)
+Closure [ <user> static public method {closure:%s:%d} ] {
+  @@ %s 16 - 16
+
+  - Parameters [2] {
+    Parameter #0 [ <required> $args0 ]
+    Parameter #1 [ <optional> ...$args ]
+  }
+}
+Foo::method
+int(10)
+Closure [ <user> static public method {closure:%s:%d} ] {
+  @@ %s 22 - 22
+
+  - Bound Variables [1] {
+      Variable #0 [ $args0 ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> ...$args ]
+  }
+}
+Foo::method
+object(Foo)#%d (0) {
+}
+int(100)
diff --git a/Zend/tests/partial_application/magic_003.phpt b/Zend/tests/partial_application/magic_003.phpt
new file mode 100644
index 0000000000000..4f7f6125d28e3
--- /dev/null
+++ b/Zend/tests/partial_application/magic_003.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Closure application magic trampoline release unused
+--FILE--
+<?php
+class Foo {
+    static function __callStatic($name, $args) {}
+}
+Foo::method(?);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/magic_004.phpt b/Zend/tests/partial_application/magic_004.phpt
new file mode 100644
index 0000000000000..893e13a238a3e
--- /dev/null
+++ b/Zend/tests/partial_application/magic_004.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Closure application magic trampoline release used
+--FILE--
+<?php
+class Foo {
+    static function __callStatic($name, $args) {}
+}
+$a = Foo::method(?);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/magic_005.phpt b/Zend/tests/partial_application/magic_005.phpt
new file mode 100644
index 0000000000000..104c85e05cb8d
--- /dev/null
+++ b/Zend/tests/partial_application/magic_005.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Closure application magic null ptr deref in arginfo
+--FILE--
+<?php
+class Foo {
+    function __call($name, $args) {
+        var_dump($args);
+    }
+}
+$foo = new Foo;
+$bar = $foo->method(?);
+var_dump($bar);
+?>
+--EXPECTF--
+object(Closure)#%d (%d) {
+  ["name"]=>
+  string(%d) "{closure:%s}"
+  ["file"]=>
+  string(73) "%smagic_005.php"
+  ["line"]=>
+  int(8)
+  ["this"]=>
+  object(Foo)#%d (0) {
+  }
+  ["parameter"]=>
+  array(1) {
+    ["$args0"]=>
+    string(10) "<required>"
+  }
+}
diff --git a/Zend/tests/partial_application/magic_006.phpt b/Zend/tests/partial_application/magic_006.phpt
new file mode 100644
index 0000000000000..f34d89f0e490f
--- /dev/null
+++ b/Zend/tests/partial_application/magic_006.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Closure application magic varargs
+--FILE--
+<?php
+class Foo {
+    function __call($name, $args) {
+        var_dump($args);
+    }
+}
+$foo = new Foo;
+$bar = $foo->method(1,...);
+$bar(2);
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
diff --git a/Zend/tests/partial_application/named_placeholder_001.phpt b/Zend/tests/partial_application/named_placeholder_001.phpt
new file mode 100644
index 0000000000000..de96e973b76e2
--- /dev/null
+++ b/Zend/tests/partial_application/named_placeholder_001.phpt
@@ -0,0 +1,117 @@
+--TEST--
+Closure application named placeholder
+--FILE--
+<?php
+
+class A {}
+class B {}
+class C {}
+
+function foo($a = 1, $b = 2, $c = 3) {
+    var_dump($a, $b, $c);
+}
+
+$foo = foo(b: ?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo(new B);
+
+$foo = $foo(?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo(new B);
+
+$foo = foo(?, ?);
+$foo = $foo(b: ?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo(new B);
+
+function bar($a = 1, $b = 2, ...$c) {
+    var_dump($a, $b, $c);
+}
+
+$bar = bar(b: ?, ...);
+
+echo (string) new ReflectionFunction($bar);
+
+$bar(new A, new B, new C);
+
+try {
+    $bar = $bar(?, a: ?);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    $bar = $bar(c: ?, ...);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %snamed_placeholder_001.php 11 - 11
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> $b = 2 ]
+  }
+}
+int(1)
+object(B)#%d (0) {
+}
+int(3)
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %snamed_placeholder_001.php 17 - 17
+
+  - Bound Variables [1] {
+      Variable #0 [ $fn ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> $b = 2 ]
+  }
+}
+int(1)
+object(B)#%d (0) {
+}
+int(3)
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %snamed_placeholder_001.php 24 - 24
+
+  - Bound Variables [1] {
+      Variable #0 [ $fn ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> $b = 2 ]
+  }
+}
+int(1)
+object(B)#%d (0) {
+}
+int(3)
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %snamed_placeholder_001.php 34 - 34
+
+  - Parameters [3] {
+    Parameter #0 [ <optional> $a = 1 ]
+    Parameter #1 [ <optional> $b = 2 ]
+    Parameter #2 [ <optional> ...$c ]
+  }
+}
+object(A)#%d (0) {
+}
+object(B)#%d (0) {
+}
+array(1) {
+  [0]=>
+  object(C)#%d (0) {
+  }
+}
+Named parameter $a overwrites previous placeholder
+Cannot use named placeholder for unknown or variadic parameter $c
diff --git a/Zend/tests/partial_application/observers.phpt b/Zend/tests/partial_application/observers.phpt
new file mode 100644
index 0000000000000..75ad85c3a0556
--- /dev/null
+++ b/Zend/tests/partial_application/observers.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Closure application observers
+--EXTENSIONS--
+zend_test
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.show_output=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+
+function f($a, $b) {
+    var_dump($a, $b);
+}
+
+$f = f(1, ...);
+$f(2);
+
+?>
+--EXPECTF--
+<!-- init '%sobservers.php' -->
+<file '%sobservers.php'>
+  <!-- init {closure:%s}() -->
+  <{closure:%s}>
+    <!-- init f() -->
+    <f>
+      <!-- init var_dump() -->
+      <var_dump>
+int(1)
+int(2)
+      </var_dump>
+    </f>
+  </{closure:%s:%d}>
+</file '%sobservers.php'>
diff --git a/Zend/tests/partial_application/pipe_optimization_001.phpt b/Zend/tests/partial_application/pipe_optimization_001.phpt
new file mode 100644
index 0000000000000..f1008dc5af939
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_001.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Closure application pipe optimization: PFA with single placeholder arg can be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a) {
+        var_dump($a);
+    }
+}
+
+1 |> foo(?);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=9, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_001.php:1-12
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 1 string("foo")
+0006 SEND_VAL_EX int(1) 1
+0007 DO_FCALL_BY_NAME
+0008 RETURN int(1)
+
+foo:
+     ; (lines=5, args=1, vars=1, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_001.php:4-6
+0000 CV0($a) = RECV 1
+0001 INIT_FCALL 1 %d string("var_dump")
+0002 SEND_VAR CV0($a) 1
+0003 DO_ICALL
+0004 RETURN null
+int(1)
diff --git a/Zend/tests/partial_application/pipe_optimization_002.phpt b/Zend/tests/partial_application/pipe_optimization_002.phpt
new file mode 100644
index 0000000000000..5883800bc8f94
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_002.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Closure application pipe optimization: PFA with only one placeholder can be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+2 |> foo(1, ?);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=10, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_002.php:1-12
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 2 string("foo")
+0006 SEND_VAL_EX int(1) 1
+0007 SEND_VAL_EX int(2) 2
+0008 DO_FCALL_BY_NAME
+0009 RETURN int(1)
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_002.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+int(1)
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_003.phpt b/Zend/tests/partial_application/pipe_optimization_003.phpt
new file mode 100644
index 0000000000000..aa75e7b02a46f
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_003.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Closure application pipe optimization: PFA with only one placeholder can be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+2 |> foo(?, 1);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=10, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_003.php:1-12
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 2 string("foo")
+0006 SEND_VAL_EX int(2) 1
+0007 SEND_VAL_EX int(1) 2
+0008 DO_FCALL_BY_NAME
+0009 RETURN int(1)
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_003.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+int(2)
+int(1)
diff --git a/Zend/tests/partial_application/pipe_optimization_004.phpt b/Zend/tests/partial_application/pipe_optimization_004.phpt
new file mode 100644
index 0000000000000..0252624a2d3cd
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_004.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Closure application pipe optimization: PFA with multiple placeholders can not be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+try {
+2 |> foo(?, ?);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=20, args=0, vars=1, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_004.php:1-16
+0000 INIT_FCALL 0 %d string("time")
+0001 V2 = DO_ICALL
+0002 T1 = IS_SMALLER int(0) V2
+0003 JMPZ T1 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 2 string("foo")
+0006 SEND_PLACEHOLDER
+0007 SEND_PLACEHOLDER
+0008 CHECK_PARTIAL_ARGS
+0009 T1 = CALLABLE_CONVERT_PARTIAL %d
+0010 INIT_DYNAMIC_CALL 1 T1
+0011 SEND_VAL_EX int(2) 1
+0012 DO_FCALL
+0013 RETURN int(1)
+0014 CV0($e) = CATCH string("Throwable")
+0015 INIT_METHOD_CALL 0 CV0($e) string("getMessage")
+0016 V1 = DO_FCALL
+0017 ECHO V1
+0018 ECHO string("\n")
+0019 RETURN int(1)
+EXCEPTION TABLE:
+     0005, 0014, -, -
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_004.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+
+$_main:
+     ; (lines=3, args=0, vars=0, tmps=1)
+     ; (after optimizer)
+     ; %s:1-10
+0000 T0 = DECLARE_LAMBDA_FUNCTION 0
+0001 FREE T0
+0002 RETURN int(1)
+
+{closure:%s:%d}:
+     ; (lines=7, args=2, vars=2, tmps=1)
+     ; (after optimizer)
+     ; %s:10-10
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 112 string("foo")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 V2 = DO_UCALL
+0006 RETURN V2
+Too few arguments to function {closure:%s:%d}(), 1 passed in %s on line %d and exactly 2 expected
diff --git a/Zend/tests/partial_application/pipe_optimization_005.phpt b/Zend/tests/partial_application/pipe_optimization_005.phpt
new file mode 100644
index 0000000000000..28b95bf18e8a4
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_005.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Closure application pipe optimization: PFA with only one placeholder can be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+2 |> foo(1, ...);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=10, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_005.php:1-12
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 2 string("foo")
+0006 SEND_VAL_EX int(1) 1
+0007 SEND_VAL_EX int(2) 2
+0008 DO_FCALL_BY_NAME
+0009 RETURN int(1)
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_005.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+int(1)
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_006.phpt b/Zend/tests/partial_application/pipe_optimization_006.phpt
new file mode 100644
index 0000000000000..8f84d152aa079
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_006.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Closure application pipe optimization: PFA with only one placeholder can be optimized (named)
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b = null, $c = null) {
+        var_dump($a, $b, $c);
+    }
+}
+
+2 |> foo(1, c: ?);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=11, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_006.php:1-12
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 1 string("foo")
+0006 SEND_VAL_EX int(1) 1
+0007 SEND_VAL_EX int(2) string("c")
+0008 CHECK_UNDEF_ARGS
+0009 DO_FCALL_BY_NAME
+0010 RETURN int(1)
+
+foo:
+     ; (lines=9, args=3, vars=3, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_006.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV_INIT 2 null
+0002 CV2($c) = RECV_INIT 3 null
+0003 INIT_FCALL 3 %d string("var_dump")
+0004 SEND_VAR CV0($a) 1
+0005 SEND_VAR CV1($b) 2
+0006 SEND_VAR CV2($c) 3
+0007 DO_ICALL
+0008 RETURN null
+int(1)
+NULL
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_007.phpt b/Zend/tests/partial_application/pipe_optimization_007.phpt
new file mode 100644
index 0000000000000..26d9b43c606d1
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_007.phpt
@@ -0,0 +1,84 @@
+--TEST--
+Closure application pipe optimization: PFA with multiple placeholders can not be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+try {
+2 |> foo(a: ?, b: ?);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=20, args=0, vars=1, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_007.php:1-16
+0000 INIT_FCALL 0 %d string("time")
+0001 V2 = DO_ICALL
+0002 T1 = IS_SMALLER int(0) V2
+0003 JMPZ T1 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 0 string("foo")
+0006 SEND_PLACEHOLDER string("a")
+0007 SEND_PLACEHOLDER string("b")
+0008 CHECK_PARTIAL_ARGS
+0009 T1 = CALLABLE_CONVERT_PARTIAL %d
+0010 INIT_DYNAMIC_CALL 1 T1
+0011 SEND_VAL_EX int(2) 1
+0012 DO_FCALL
+0013 RETURN int(1)
+0014 CV0($e) = CATCH string("Throwable")
+0015 INIT_METHOD_CALL 0 CV0($e) string("getMessage")
+0016 V1 = DO_FCALL
+0017 ECHO V1
+0018 ECHO string("\n")
+0019 RETURN int(1)
+EXCEPTION TABLE:
+     0005, 0014, -, -
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_007.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+
+$_main:
+     ; (lines=3, args=0, vars=0, tmps=1)
+     ; (after optimizer)
+     ; %s:1-10
+0000 T0 = DECLARE_LAMBDA_FUNCTION 0
+0001 FREE T0
+0002 RETURN int(1)
+
+{closure:%s:%d}:
+     ; (lines=7, args=2, vars=2, tmps=1)
+     ; (after optimizer)
+     ; %s:10-10
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 112 string("foo")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 V2 = DO_UCALL
+0006 RETURN V2
+Too few arguments to function {closure:%s:%d}(), 1 passed in %s on line %d and exactly 2 expected
diff --git a/Zend/tests/partial_application/pipe_optimization_008.phpt b/Zend/tests/partial_application/pipe_optimization_008.phpt
new file mode 100644
index 0000000000000..a4603baba6180
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_008.phpt
@@ -0,0 +1,99 @@
+--TEST--
+Closure application pipe optimization: PFA with both a variadic placeholder and named arg can not be optimized
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b) {
+        var_dump($a, $b);
+    }
+}
+
+try {
+    2 |> foo(a: 1, ...);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=20, args=0, vars=1, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_008.php:1-16
+0000 INIT_FCALL 0 %d string("time")
+0001 V2 = DO_ICALL
+0002 T1 = IS_SMALLER int(0) V2
+0003 JMPZ T1 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 0 string("foo")
+0006 SEND_VAL_EX int(1) string("a")
+0007 SEND_PLACEHOLDER
+0008 CHECK_PARTIAL_ARGS
+0009 T1 = CALLABLE_CONVERT_PARTIAL %d
+0010 INIT_DYNAMIC_CALL 1 T1
+0011 SEND_VAL_EX int(2) 1
+0012 DO_FCALL
+0013 RETURN int(1)
+0014 CV0($e) = CATCH string("Throwable")
+0015 INIT_METHOD_CALL 0 CV0($e) string("getMessage")
+0016 V1 = DO_FCALL
+0017 ECHO V1
+0018 ECHO string("\n")
+0019 RETURN int(1)
+EXCEPTION TABLE:
+     0005, 0014, -, -
+
+foo:
+     ; (lines=7, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_008.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 RETURN null
+
+$_main:
+     ; (lines=4, args=0, vars=1, tmps=1)
+     ; (after optimizer)
+     ; %s:1-10
+0000 T1 = DECLARE_LAMBDA_FUNCTION 0
+0001 BIND_LEXICAL T1 CV0($a)
+0002 FREE T1
+0003 RETURN int(1)
+LIVE RANGES:
+     1: 0001 - 0002 (tmp/var)
+
+{closure:%s:%d}:
+     ; (lines=18, args=1, vars=2, tmps=2)
+     ; (after optimizer)
+     ; %s:10-10
+0000 CV0($b) = RECV 1
+0001 BIND_STATIC CV1($a)
+0002 T3 = FUNC_NUM_ARGS
+0003 T2 = IS_SMALLER_OR_EQUAL T3 int(1)
+0004 JMPZ T2 0010
+0005 INIT_FCALL 2 112 string("foo")
+0006 SEND_VAR CV1($a) 1
+0007 SEND_VAR CV0($b) 2
+0008 V2 = DO_UCALL
+0009 RETURN V2
+0010 INIT_FCALL 2 112 string("foo")
+0011 SEND_VAR CV1($a) 1
+0012 SEND_VAR CV0($b) 2
+0013 T2 = FUNC_GET_ARGS int(1)
+0014 SEND_UNPACK T2
+0015 CHECK_UNDEF_ARGS
+0016 V2 = DO_UCALL
+0017 RETURN V2
+int(1)
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_009.phpt b/Zend/tests/partial_application/pipe_optimization_009.phpt
new file mode 100644
index 0000000000000..e0644b8af4fc6
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_009.phpt
@@ -0,0 +1,101 @@
+--TEST--
+Closure application pipe optimization: Evaluation order
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b, $c) {
+        var_dump($a, $b, $c);
+    }
+    function lhs() {
+        echo __FUNCTION__, "\n";
+        return 0;
+    }
+    function arg1() {
+        echo __FUNCTION__, "\n";
+        return 1;
+    }
+    function arg2() {
+        echo __FUNCTION__, "\n";
+        return 2;
+    }
+}
+
+lhs() |> foo(arg1(), ?, arg2());
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=21, args=0, vars=0, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_009.php:1-24
+0000 INIT_FCALL 0 %d string("time")
+0001 V1 = DO_ICALL
+0002 T0 = IS_SMALLER int(0) V1
+0003 JMPZ T0 0008
+0004 DECLARE_FUNCTION string("foo") 0
+0005 DECLARE_FUNCTION string("lhs") 1
+0006 DECLARE_FUNCTION string("arg1") 2
+0007 DECLARE_FUNCTION string("arg2") 3
+0008 INIT_FCALL_BY_NAME 0 string("lhs")
+0009 V1 = DO_FCALL_BY_NAME
+0010 T0 = QM_ASSIGN V1
+0011 INIT_FCALL_BY_NAME 3 string("foo")
+0012 INIT_FCALL_BY_NAME 0 string("arg1")
+0013 V1 = DO_FCALL_BY_NAME
+0014 SEND_VAR_NO_REF_EX V1 1
+0015 SEND_VAL_EX T0 2
+0016 INIT_FCALL_BY_NAME 0 string("arg2")
+0017 V0 = DO_FCALL_BY_NAME
+0018 SEND_VAR_NO_REF_EX V0 3
+0019 DO_FCALL_BY_NAME
+0020 RETURN int(1)
+LIVE RANGES:
+     0: 0011 - 0015 (tmp/var)
+
+foo:
+     ; (lines=9, args=3, vars=3, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_009.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 CV2($c) = RECV 3
+0003 INIT_FCALL 3 %d string("var_dump")
+0004 SEND_VAR CV0($a) 1
+0005 SEND_VAR CV1($b) 2
+0006 SEND_VAR CV2($c) 3
+0007 DO_ICALL
+0008 RETURN null
+
+lhs:
+     ; (lines=2, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_009.php:7-10
+0000 ECHO string("lhs\n")
+0001 RETURN int(0)
+
+arg1:
+     ; (lines=2, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_009.php:11-14
+0000 ECHO string("arg1\n")
+0001 RETURN int(1)
+
+arg2:
+     ; (lines=2, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_009.php:15-18
+0000 ECHO string("arg2\n")
+0001 RETURN int(2)
+lhs
+arg1
+arg2
+int(1)
+int(0)
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_010.phpt b/Zend/tests/partial_application/pipe_optimization_010.phpt
new file mode 100644
index 0000000000000..b69641164d519
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_010.phpt
@@ -0,0 +1,56 @@
+--TEST--
+Closure application pipe optimization: References
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo(&$a, $b) {
+        var_dump($a, $b);
+        $a = 2;
+    }
+}
+
+1 |> foo($a, ?);
+var_dump($a);
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=13, args=0, vars=1, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_010.php:1-14
+0000 INIT_FCALL 0 %d string("time")
+0001 V2 = DO_ICALL
+0002 T1 = IS_SMALLER int(0) V2
+0003 JMPZ T1 0005
+0004 DECLARE_FUNCTION string("foo") 0
+0005 INIT_FCALL_BY_NAME 2 string("foo")
+0006 SEND_VAR_EX CV0($a) 1
+0007 SEND_VAL_EX int(1) 2
+0008 DO_FCALL_BY_NAME
+0009 INIT_FCALL 1 %d string("var_dump")
+0010 SEND_VAR CV0($a) 1
+0011 DO_ICALL
+0012 RETURN int(1)
+
+foo:
+     ; (lines=8, args=2, vars=2, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_010.php:4-7
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 INIT_FCALL 2 %d string("var_dump")
+0003 SEND_VAR CV0($a) 1
+0004 SEND_VAR CV1($b) 2
+0005 DO_ICALL
+0006 ASSIGN CV0($a) int(2)
+0007 RETURN null
+NULL
+int(1)
+int(2)
diff --git a/Zend/tests/partial_application/pipe_optimization_011.phpt b/Zend/tests/partial_application/pipe_optimization_011.phpt
new file mode 100644
index 0000000000000..8fc4c51783c44
--- /dev/null
+++ b/Zend/tests/partial_application/pipe_optimization_011.phpt
@@ -0,0 +1,108 @@
+--TEST--
+Closure application pipe optimization: Evaluation order
+--EXTENSIONS--
+opcache
+--INI--
+opcache.opt_debug_level=0x20000
+opcache.enable=1
+opcache.enable_cli=1
+--FILE--
+<?php
+
+if (time() > 0) {
+    function foo($a, $b, $c) {
+        var_dump($a, $b, $c);
+    }
+    function lhs() {
+        echo __FUNCTION__, "\n";
+        return 0;
+    }
+    function arg1() {
+        global $a;
+        $a = 2;
+        echo __FUNCTION__, "\n";
+        return 1;
+    }
+    function arg2() {
+        global $a;
+        $a = 3;
+        echo __FUNCTION__, "\n";
+        return 2;
+    }
+}
+
+$a = 0;
+$a |> foo(arg1(), ?, arg2());
+
+?>
+--EXPECTF--
+$_main:
+     ; (lines=20, args=0, vars=1, tmps=2)
+     ; (after optimizer)
+     ; %spipe_optimization_011.php:1-29
+0000 INIT_FCALL 0 %d string("time")
+0001 V2 = DO_ICALL
+0002 T1 = IS_SMALLER int(0) V2
+0003 JMPZ T1 0008
+0004 DECLARE_FUNCTION string("foo") 0
+0005 DECLARE_FUNCTION string("lhs") 1
+0006 DECLARE_FUNCTION string("arg1") 2
+0007 DECLARE_FUNCTION string("arg2") 3
+0008 ASSIGN CV0($a) int(0)
+0009 T1 = QM_ASSIGN CV0($a)
+0010 INIT_FCALL_BY_NAME 3 string("foo")
+0011 INIT_FCALL_BY_NAME 0 string("arg1")
+0012 V2 = DO_FCALL_BY_NAME
+0013 SEND_VAR_NO_REF_EX V2 1
+0014 SEND_VAL_EX T1 2
+0015 INIT_FCALL_BY_NAME 0 string("arg2")
+0016 V1 = DO_FCALL_BY_NAME
+0017 SEND_VAR_NO_REF_EX V1 3
+0018 DO_FCALL_BY_NAME
+0019 RETURN int(1)
+LIVE RANGES:
+     1: 0010 - 0014 (tmp/var)
+
+foo:
+     ; (lines=9, args=3, vars=3, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_011.php:4-6
+0000 CV0($a) = RECV 1
+0001 CV1($b) = RECV 2
+0002 CV2($c) = RECV 3
+0003 INIT_FCALL 3 %d string("var_dump")
+0004 SEND_VAR CV0($a) 1
+0005 SEND_VAR CV1($b) 2
+0006 SEND_VAR CV2($c) 3
+0007 DO_ICALL
+0008 RETURN null
+
+lhs:
+     ; (lines=2, args=0, vars=0, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_011.php:7-10
+0000 ECHO string("lhs\n")
+0001 RETURN int(0)
+
+arg1:
+     ; (lines=4, args=0, vars=1, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_011.php:11-16
+0000 BIND_GLOBAL CV0($a) string("a")
+0001 ASSIGN CV0($a) int(2)
+0002 ECHO string("arg1\n")
+0003 RETURN int(1)
+
+arg2:
+     ; (lines=4, args=0, vars=1, tmps=0)
+     ; (after optimizer)
+     ; %spipe_optimization_011.php:17-22
+0000 BIND_GLOBAL CV0($a) string("a")
+0001 ASSIGN CV0($a) int(3)
+0002 ECHO string("arg2\n")
+0003 RETURN int(2)
+arg1
+arg2
+int(1)
+int(0)
+int(2)
diff --git a/Zend/tests/partial_application/rebinding_001.phpt b/Zend/tests/partial_application/rebinding_001.phpt
new file mode 100644
index 0000000000000..3de5271c6508b
--- /dev/null
+++ b/Zend/tests/partial_application/rebinding_001.phpt
@@ -0,0 +1,63 @@
+--TEST--
+Closure application can only be rebound to an instanceof $this
+--FILE--
+<?php
+
+class C {
+    function f($a) { var_dump($this); }
+    static function g($a) { var_dump(static::class); }
+}
+
+class SubClass extends C {}
+
+class Unrelated {}
+
+$c = new C;
+$f = $c->f(?);
+$g = $c->g(?);
+
+echo "# Can be rebound to \$this of the same class:\n";
+$f->bindTo(new C)(1);
+
+echo "# Can be rebound to \$this of a sub-class:\n";
+$f->bindTo(new SubClass)(1);
+
+echo "# Cannot be rebound to an unrelated class:\n";
+try {
+    $f->bindTo(new Unrelated)(1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "# Cannot unbind \$this on instance method:\n";
+try {
+    $f->bindTo(null)(1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "# Can unbind \$this on static method:\n";
+try {
+    $g->bindTo(null)(1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+# Can be rebound to $this of the same class:
+object(C)#%d (0) {
+}
+# Can be rebound to $this of a sub-class:
+object(SubClass)#%d (0) {
+}
+# Cannot be rebound to an unrelated class:
+
+Warning: Cannot bind method C::{closure:%s:%d}() to object of class Unrelated, this will be an error in PHP 9 in %s on line %d
+Value of type null is not callable
+# Cannot unbind $this on instance method:
+
+Warning: Cannot unbind $this of method, this will be an error in PHP 9 in %s on line %d
+Value of type null is not callable
+# Can unbind $this on static method:
+string(1) "C"
diff --git a/Zend/tests/partial_application/rebinding_002.phpt b/Zend/tests/partial_application/rebinding_002.phpt
new file mode 100644
index 0000000000000..293261dcb6988
--- /dev/null
+++ b/Zend/tests/partial_application/rebinding_002.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Closure application scope cannot be rebound
+--FILE--
+<?php
+
+class C {
+    function f($a) { var_dump(static::class); }
+}
+
+class SubClass extends C {}
+
+function g($a) { var_dump(__FUNCTION__); }
+
+$c = new C;
+$f = $c->f(?);
+$g = g(?);
+
+echo "# Can be rebound to the same scope:\n";
+$f->bindTo($c, C::class)(1);
+
+echo "# Method cannot be rebound to a different scope:\n";
+try {
+    $f->bindTo($c, SubClass::class)(1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+echo "# Function cannot be refound to a different scope:\n";
+try {
+    $g->bindTo($c, SubClass::class)(1);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+?>
+--EXPECTF--
+# Can be rebound to the same scope:
+string(1) "C"
+# Method cannot be rebound to a different scope:
+
+Warning: Cannot rebind scope of closure created from method, this will be an error in PHP 9 in %s on line %d
+Value of type null is not callable
+# Function cannot be refound to a different scope:
+
+Warning: Cannot bind an instance to a static closure, this will be an error in PHP 9 in %s on line %d
+Value of type null is not callable
diff --git a/Zend/tests/partial_application/references_001.phpt b/Zend/tests/partial_application/references_001.phpt
new file mode 100644
index 0000000000000..94c67399063d4
--- /dev/null
+++ b/Zend/tests/partial_application/references_001.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Closure application references 001
+--FILE--
+<?php
+
+function foo($a, $b) {
+    $b = 2;
+}
+
+$a = [];
+$b = &$a[0];
+
+$foo = foo(1, ?);
+$foo($b);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  &NULL
+}
+NULL
diff --git a/Zend/tests/partial_application/references_002.phpt b/Zend/tests/partial_application/references_002.phpt
new file mode 100644
index 0000000000000..84411898d37d0
--- /dev/null
+++ b/Zend/tests/partial_application/references_002.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Closure application references 002
+--FILE--
+<?php
+
+function foo($a, &$b) {
+    $b = 2;
+}
+
+$a = [];
+$b = &$a[0];
+
+$foo = foo(1, ?);
+$foo($b);
+
+var_dump($a, $b);
+
+?>
+--EXPECT--
+array(1) {
+  [0]=>
+  &int(2)
+}
+int(2)
diff --git a/Zend/tests/partial_application/references_003.phpt b/Zend/tests/partial_application/references_003.phpt
new file mode 100644
index 0000000000000..233c94b673305
--- /dev/null
+++ b/Zend/tests/partial_application/references_003.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Closure application references 003
+--FILE--
+<?php
+
+function foo($a, &$b) {
+    $a = 2;
+}
+
+$foo = foo(1, ?);
+
+try {
+    $foo(2);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+{closure:%s}(): Argument #1 ($b) could not be passed by reference
diff --git a/Zend/tests/partial_application/references_004.phpt b/Zend/tests/partial_application/references_004.phpt
new file mode 100644
index 0000000000000..734a40349f1a9
--- /dev/null
+++ b/Zend/tests/partial_application/references_004.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Closure application references 004
+--FILE--
+<?php
+
+function foo(&$a, $b) {
+}
+
+try {
+    $foo = foo(1, ?);
+} catch (\Throwable $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECT--
+foo(): Argument #1 ($a) could not be passed by reference
diff --git a/Zend/tests/partial_application/references_005.phpt b/Zend/tests/partial_application/references_005.phpt
new file mode 100644
index 0000000000000..4a69e9fd9f461
--- /dev/null
+++ b/Zend/tests/partial_application/references_005.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Closure application references 005
+--FILE--
+<?php
+
+function foo($a, &...$args) {
+    foreach ($args as &$arg) {
+        $arg = -$arg;
+    }
+}
+
+$b = 2;
+$c = 3;
+$d = 4;
+
+$foo = foo(1, $b, ?, ...);
+
+echo (string) new ReflectionFunction($foo), "\n";
+
+$foo($c, $d);
+
+var_dump($b, $c, $d);
+
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreferences_005.php 13 - 13
+
+  - Bound Variables [2] {
+      Variable #0 [ $a ]
+      Variable #1 [ $args0 ]
+  }
+
+  - Parameters [2] {
+    Parameter #0 [ <required> &$args1 ]
+    Parameter #1 [ <optional> &...$args ]
+  }
+}
+
+int(-2)
+int(-3)
+int(-4)
diff --git a/Zend/tests/partial_application/reflection_001.phpt b/Zend/tests/partial_application/reflection_001.phpt
new file mode 100644
index 0000000000000..87c3788980354
--- /dev/null
+++ b/Zend/tests/partial_application/reflection_001.phpt
@@ -0,0 +1,48 @@
+--TEST--
+Closure application reflection: required parameters
+--FILE--
+<?php
+function foo($a = 1, $b = 5, $c = 10) {
+
+}
+
+$foo = foo(?, ...);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = foo(?, ?, ...);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = foo(?, ?, ?);
+
+echo (string) new ReflectionFunction($foo);
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_001.php 6 - 6
+
+  - Parameters [3] {
+    Parameter #0 [ <optional> $a = 1 ]
+    Parameter #1 [ <optional> $b = 5 ]
+    Parameter #2 [ <optional> $c = 10 ]
+  }
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_001.php 10 - 10
+
+  - Parameters [3] {
+    Parameter #0 [ <optional> $a = 1 ]
+    Parameter #1 [ <optional> $b = 5 ]
+    Parameter #2 [ <optional> $c = 10 ]
+  }
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_001.php 14 - 14
+
+  - Parameters [3] {
+    Parameter #0 [ <optional> $a = 1 ]
+    Parameter #1 [ <optional> $b = 5 ]
+    Parameter #2 [ <optional> $c = 10 ]
+  }
+}
diff --git a/Zend/tests/partial_application/reflection_002.phpt b/Zend/tests/partial_application/reflection_002.phpt
new file mode 100644
index 0000000000000..85d9d34a0424e
--- /dev/null
+++ b/Zend/tests/partial_application/reflection_002.phpt
@@ -0,0 +1,57 @@
+--TEST--
+Closure application reflection: variadics
+--FILE--
+<?php
+function foo($a, ...$b) {
+    var_dump(func_get_args());
+}
+
+$foo = foo(?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = foo(?, ...);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = foo(?, ?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = foo(?, ?, ?);
+
+echo (string) new ReflectionFunction($foo);
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 6 - 6
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $a ]
+  }
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 10 - 10
+
+  - Parameters [2] {
+    Parameter #0 [ <required> $a ]
+    Parameter #1 [ <optional> ...$b ]
+  }
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 14 - 14
+
+  - Parameters [2] {
+    Parameter #0 [ <required> $a ]
+    Parameter #1 [ <required> $b0 ]
+  }
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 18 - 18
+
+  - Parameters [3] {
+    Parameter #0 [ <required> $a ]
+    Parameter #1 [ <required> $b0 ]
+    Parameter #2 [ <required> $b1 ]
+  }
+}
diff --git a/Zend/tests/partial_application/reflection_003.phpt b/Zend/tests/partial_application/reflection_003.phpt
new file mode 100644
index 0000000000000..bb27eb1bb0bac
--- /dev/null
+++ b/Zend/tests/partial_application/reflection_003.phpt
@@ -0,0 +1,43 @@
+--TEST--
+Closure application reflection: internal with variadics
+--FILE--
+<?php
+$foo = sprintf(?);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = sprintf(?, ...);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo = sprintf(?, ?);
+
+echo (string) new ReflectionFunction($foo);
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_003.php 2 - 2
+
+  - Parameters [1] {
+    Parameter #0 [ <required> string $format ]
+  }
+  - Return [ string ]
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_003.php 6 - 6
+
+  - Parameters [2] {
+    Parameter #0 [ <required> string $format ]
+    Parameter #1 [ <optional> mixed ...$values ]
+  }
+  - Return [ string ]
+}
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %sreflection_003.php 10 - 10
+
+  - Parameters [2] {
+    Parameter #0 [ <required> string $format ]
+    Parameter #1 [ <required> mixed $values0 ]
+  }
+  - Return [ string ]
+}
diff --git a/Zend/tests/partial_application/reflection_004.phpt b/Zend/tests/partial_application/reflection_004.phpt
new file mode 100644
index 0000000000000..aa0ae6d4b7d3b
--- /dev/null
+++ b/Zend/tests/partial_application/reflection_004.phpt
@@ -0,0 +1,13 @@
+--TEST--
+Closure application reflection: ReflectionFunction::isClosure() is true for partials
+--FILE--
+<?php
+
+echo (int)(new ReflectionFunction('sprintf'))->isClosure(), "\n";
+
+echo (int)(new ReflectionFunction(sprintf(?)))->isClosure(), "\n";
+
+?>
+--EXPECT--
+0
+1
diff --git a/Zend/tests/partial_application/reflection_005.phpt b/Zend/tests/partial_application/reflection_005.phpt
new file mode 100644
index 0000000000000..2836a617b58a5
--- /dev/null
+++ b/Zend/tests/partial_application/reflection_005.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application reflection: ReflectionFunction::isClosure() is true for partials
+--FILE--
+<?php
+
+echo (int)(new ReflectionFunction('sprintf'))->isClosure(), "\n";
+
+echo (int)(new ReflectionFunction(function () {}))->isClosure(), "\n";
+
+echo (int)(new ReflectionFunction(sprintf(?)))->isClosure(), "\n";
+
+?>
+--EXPECTF--
+0
+1
+1
diff --git a/Zend/tests/partial_application/relative_return_types.phpt b/Zend/tests/partial_application/relative_return_types.phpt
new file mode 100644
index 0000000000000..5c3101357111e
--- /dev/null
+++ b/Zend/tests/partial_application/relative_return_types.phpt
@@ -0,0 +1,133 @@
+--TEST--
+Closure application: relative return types
+--FILE--
+<?php
+
+if (time() > 0) {
+    trait T {
+        public function getSelf(object $o): self {
+            return $o;
+        }
+        public function getStatic(object $o): static {
+            return $o;
+        }
+    }
+}
+
+class C {
+    use T;
+}
+
+class D extends C {
+}
+
+$c = new C;
+
+$self = $c->getSelf(?);
+
+echo (string) new ReflectionFunction($self), "\n";
+
+var_dump($self($c));
+var_dump($self(new D));
+try {
+    $self(new stdClass);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+$static = $c->getStatic(?);
+
+echo (string) new ReflectionFunction($static), "\n";
+
+var_dump($static($c));
+var_dump($static(new D));
+try {
+    $static(new stdClass);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+$d = new D;
+
+$self = $d->getSelf(?);
+
+echo (string) new ReflectionFunction($self), "\n";
+
+var_dump($self($d));
+var_dump($self(new D));
+try {
+    $self(new stdClass);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+$static = $d->getStatic(?);
+
+echo (string) new ReflectionFunction($static), "\n";
+
+var_dump($static($d));
+var_dump($static(new D));
+try {
+    $static(new stdClass);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 23 - 23
+
+  - Parameters [1] {
+    Parameter #0 [ <required> object $o ]
+  }
+  - Return [ self ]
+}
+
+object(C)#%d (0) {
+}
+object(D)#%d (0) {
+}
+C::getSelf(): Return value must be of type C, stdClass returned
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 35 - 35
+
+  - Parameters [1] {
+    Parameter #0 [ <required> object $o ]
+  }
+  - Return [ static ]
+}
+
+object(C)#%d (0) {
+}
+object(D)#%d (0) {
+}
+C::getStatic(): Return value must be of type C, stdClass returned
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 49 - 49
+
+  - Parameters [1] {
+    Parameter #0 [ <required> object $o ]
+  }
+  - Return [ self ]
+}
+
+object(D)#%d (0) {
+}
+object(D)#%d (0) {
+}
+C::getSelf(): Return value must be of type C, stdClass returned
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %s.php 61 - 61
+
+  - Parameters [1] {
+    Parameter #0 [ <required> object $o ]
+  }
+  - Return [ static ]
+}
+
+object(D)#%d (0) {
+}
+object(D)#%d (0) {
+}
+C::getStatic(): Return value must be of type D, stdClass returned
diff --git a/Zend/tests/partial_application/return_type_001.phpt b/Zend/tests/partial_application/return_type_001.phpt
new file mode 100644
index 0000000000000..2a54563324411
--- /dev/null
+++ b/Zend/tests/partial_application/return_type_001.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Closure application return type
+--FILE--
+<?php
+function foo($a) : array {}
+
+echo (string) new ReflectionFunction(foo(new stdClass, ...));
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 4 - 4
+
+  - Bound Variables [1] {
+      Variable #0 [ $a ]
+  }
+
+  - Parameters [0] {
+  }
+  - Return [ array ]
+}
diff --git a/Zend/tests/partial_application/rfc_examples_001.phpt b/Zend/tests/partial_application/rfc_examples_001.phpt
new file mode 100644
index 0000000000000..faddcb0574678
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_001.phpt
@@ -0,0 +1,152 @@
+--TEST--
+Closure application RFC examples: equivalence
+--FILE--
+<?php
+
+function stuff(int $i, string $s, float $f, Point $p, int $m = 0): array {
+    return [$i, $s, $f, $p, $m];
+}
+
+class Point {
+}
+
+$point = new Point();
+
+$tests = [
+    'Manually specify the first two values, and pull the rest "as is"' => [
+        stuff(?, ?, ?, ?, ?),
+        fn(int $i, string $s, float $f, Point $p, int $m = 0): array => stuff($i, $s, $f, $p, $m),
+    ],
+    'Manually specify the first two values, and pull the rest "as is" (2)' => [
+        stuff(?, ?, ...),
+        fn(int $i, string $s, float $f, Point $p, int $m = 0): array => stuff($i, $s, $f, $p, $m),
+    ],
+    'The degenerate "first class callables" case. (Supported since 8.1)' => [
+        stuff(...),
+        fn(int $i, string $s, float $f, Point $p, int $m = 0): array => stuff($i, $s, $f, $p, $m),
+    ],
+    'Provide some values, require the rest to be provided later' => [
+        stuff(1, 'hi', ?, ?, ?),
+        fn(float $f, Point $p, int $m = 0): array => stuff(1, 'hi', $f, $p, $m),
+    ],
+    'Provide some values, require the rest to be provided later (2)' => [
+        stuff(1, 'hi', ...),
+        fn(float $f, Point $p, int $m = 0): array => stuff(1, 'hi', $f, $p, $m),
+    ],
+    'Provided some values, but not just from the left' => [
+        stuff(1, ?, 3.5, ?, ?),
+        fn(string $s, Point $p, int $m = 0): array => stuff(1, $s, 3.5, $p, $m),
+    ],
+    'Provided some values, but not just from the left (2)' => [
+        stuff(1, ?, 3.5, ...),
+        fn(string $s, Point $p, int $m = 0): array => stuff(1, $s, 3.5, $p, $m),
+    ],
+    'Provide just the last value' => [
+        stuff(?, ?, ?, ?, 5),
+        fn(int $i, string $s, float $f, Point $p): array => stuff($i, $s, $f, $p, 5),
+    ],
+    'Not accounting for an optional argument means it will always get its default value' => [
+        stuff(?, ?, ?, ?),
+        fn(int $i, string $s, float $f, Point $p): array => stuff($i, $s, $f, $p),
+    ],
+    'Named arguments can be pulled "out of order", and still work' => [
+        stuff(?, ?, f: 3.5, p: $point),
+        fn(int $i, string $s): array => stuff($i, $s, 3.5, $point),
+    ],
+    'Named arguments can be pulled "out of order", and still work (2)' => [
+        stuff(?, ?, p: $point, f: 3.5),
+        fn(int $i, string $s): array => stuff($i, $s, 3.5, $point),
+    ],
+    'The ... "everything else" placeholder respects named arguments' => [
+        stuff(?, ?, f: 3.5, p: $point, ...),
+        fn(int $i, string $s, int $m = 0): array => stuff($i, $s, 3.5, $point, $m),
+    ],
+    'Prefill all parameters, making a "delayed call" or "thunk"' => [
+        stuff(1, 'hi', 3.4, $point, 5, ...),
+        fn(): array => stuff(1, 'hi', 3.4, $point, 5),
+    ],
+    'Placeholders may be named, too.  Their order doesn\'t matter as long as they come before the ..., if any' => [
+        stuff(?, p: $point, f: ?, s: ?, m: 4),
+        fn(int $i, string $s, float $f): array => stuff($i, $s, $f, $point, 4),
+    ],
+    'Placeholders may be named, too.  Their order doesn\'t matter as long as they come before the ..., if any (2)' => [
+        stuff(m: 4, p: $point, i: ?, ...),
+        fn(int $i, string $s, float $f): array => stuff($i, $s, $f, $point, 4),
+    ],
+];
+
+foreach ($tests as $test => [$pfa, $closure]) {
+    echo "# ", $test, "\n";
+    $pfaReflector = new ReflectionFunction($pfa);
+    $closureReflector = new ReflectionFunction($closure);
+
+    try {
+        if (count($pfaReflector->getParameters()) !== count($closureReflector->getParameters())) {
+            throw new Exception("Arity does not match");
+        }
+
+        $it = new MultipleIterator();
+        $it->attachIterator(new ArrayIterator($pfaReflector->getParameters()));
+        $it->attachIterator(new ArrayIterator($closureReflector->getParameters()));
+        foreach ($it as $i => [$pfaParam, $closureParam]) {
+            [$i] = $i;
+            if ($pfaParam->getName() !== $closureParam->getName()) {
+                throw new Exception(sprintf("Name of param %d does not match: %s vs %s",
+                    $i,
+                    $pfaParam->getName(),
+                    $closureParam->getName(),
+                ));
+            }
+            if ((string)$pfaParam->getType() !== (string)$closureParam->getType()) {
+                throw new Exception(sprintf("Type of param %d does not match: %s vs %s",
+                    $i,
+                    $pfaParam->getType(),
+                    $closureParam->getType(),
+                ));
+            }
+            if ($pfaParam->isOptional() !== $closureParam->isOptional()) {
+                throw new Exception(sprintf("Optionalness of param %d does not match: %d vs %d",
+                    $i,
+                    $pfaParam->isOptional(),
+                    $closureParam->isOptional(),
+                ));
+            }
+        }
+    } catch (Exception $e) {
+        echo $e->getMessage(), "\n";
+        echo $pfaReflector;
+        echo $closureReflector;
+    }
+
+    $args = [];
+    foreach ($pfaReflector->getParameters() as $i => $p) {
+        $args[] = match ((string) $p->getType()) {
+            'int' => 100 + $i,
+            'float' => 100.5 + $i,
+            'string' => (string) (100 + $i),
+            'Point' => new Point,
+        };
+    }
+
+    if ($pfa(...$args) !== $closure(...$args)) {
+        echo "PFA is not equivalent to closure\n";
+    }
+}
+
+?>
+--EXPECT--
+# Manually specify the first two values, and pull the rest "as is"
+# Manually specify the first two values, and pull the rest "as is" (2)
+# The degenerate "first class callables" case. (Supported since 8.1)
+# Provide some values, require the rest to be provided later
+# Provide some values, require the rest to be provided later (2)
+# Provided some values, but not just from the left
+# Provided some values, but not just from the left (2)
+# Provide just the last value
+# Not accounting for an optional argument means it will always get its default value
+# Named arguments can be pulled "out of order", and still work
+# Named arguments can be pulled "out of order", and still work (2)
+# The ... "everything else" placeholder respects named arguments
+# Prefill all parameters, making a "delayed call" or "thunk"
+# Placeholders may be named, too.  Their order doesn't matter as long as they come before the ..., if any
+# Placeholders may be named, too.  Their order doesn't matter as long as they come before the ..., if any (2)
diff --git a/Zend/tests/partial_application/rfc_examples_002.phpt b/Zend/tests/partial_application/rfc_examples_002.phpt
new file mode 100644
index 0000000000000..36664b3125036
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_002.phpt
@@ -0,0 +1,118 @@
+--TEST--
+Closure application RFC examples: variadics equivalence
+--XFAIL--
+Name of params for positional placeholders that run into the variadic portion is wrong
+--FILE--
+<?php
+
+function things(int $i, ?float $f = null, Point ...$points): array {
+    return [$i, $f, $points];
+}
+
+class Point {
+}
+
+$point = new Point();
+
+$tests = [
+    'FCC equivalent. The signature is unchanged' => [
+        things(...),
+        fn(int $i, ?float $f = null, Point ...$points): array => things(...[$i, $f, ...$points]),
+    ],
+    'Provide some values, but allow the variadic to remain variadic' => [
+        things(1, 3.14, ...),
+        fn(Point ...$points): array => things(...[1, 3.14, ...$points]),
+    ],
+    'In this version, the partial requires precisely four arguments, the last two of which will get received by things() in the variadic parameter. Note too that $f becomes required in this case.' => [
+        things(?, ?, ?, ?),
+        fn(int $i, ?float $f, Point $p1, Point $p2): array => things($i, $f, $p1, $p2),
+    ],
+];
+
+foreach ($tests as $test => [$pfa, $closure]) {
+    echo "# ", $test, "\n";
+    $pfaReflector = new ReflectionFunction($pfa);
+    $closureReflector = new ReflectionFunction($closure);
+
+    try {
+        if (count($pfaReflector->getParameters()) !== count($closureReflector->getParameters())) {
+            throw new Exception("Arity does not match");
+        }
+
+        $it = new MultipleIterator();
+        $it->attachIterator(new ArrayIterator($pfaReflector->getParameters()));
+        $it->attachIterator(new ArrayIterator($closureReflector->getParameters()));
+        foreach ($it as $i => [$pfaParam, $closureParam]) {
+            [$i] = $i;
+            if ($pfaParam->getName() !== $closureParam->getName()) {
+                throw new Exception(sprintf("Name of param %d does not match: %s vs %s",
+                    $i,
+                    $pfaParam->getName(),
+                    $closureParam->getName(),
+                ));
+            }
+            if ((string)$pfaParam->getType() !== (string)$closureParam->getType()) {
+                throw new Exception(sprintf("Type of param %d does not match: %s vs %s",
+                    $i,
+                    $pfaParam->getType(),
+                    $closureParam->getType(),
+                ));
+            }
+            if ($pfaParam->isOptional() !== $closureParam->isOptional()) {
+                throw new Exception(sprintf("Optionalness of param %d does not match: %d vs %d",
+                    $i,
+                    $pfaParam->isOptional(),
+                    $closureParam->isOptional(),
+                ));
+            }
+        }
+    } catch (Exception $e) {
+        echo $e->getMessage(), "\n";
+        echo $pfaReflector;
+        echo $closureReflector;
+    }
+
+    $args = [];
+    foreach ($pfaReflector->getParameters() as $i => $p) {
+        $args[] = match ((string) $p->getType()) {
+            'int' => 100 + $i,
+            'float' => 100.5 + $i,
+            '?float' => 100.5 + $i,
+            'string' => (string) (100 + $i),
+            'Point' => new Point,
+        };
+    }
+
+    if ($pfa(...$args) !== $closure(...$args)) {
+        echo "PFA is not equivalent to closure\n";
+    }
+}
+
+?>
+--EXPECTF--
+# FCC equivalent. The signature is unchanged
+# Provide some values, but allow the variadic to remain variadic
+# In this version, the partial requires precisely four arguments, the last two of which will get received by things() in the variadic parameter. Note too that $f becomes required in this case.
+Name of param 2 does not match: points vs p1
+Closure [ <user> function things ] {
+  @@ %srfc_examples_002.php 22 - 22
+
+  - Parameters [4] {
+    Parameter #0 [ <required> int $i ]
+    Parameter #1 [ <required> ?float $f ]
+    Parameter #2 [ <required> Point $points ]
+    Parameter #3 [ <required> Point $points ]
+  }
+  - Return [ array ]
+}
+Closure [ <user> function {closure:%s:%d} ] {
+  @@ %srfc_examples_002.php 23 - 23
+
+  - Parameters [4] {
+    Parameter #0 [ <required> int $i ]
+    Parameter #1 [ <required> ?float $f ]
+    Parameter #2 [ <required> Point $p1 ]
+    Parameter #3 [ <required> Point $p2 ]
+  }
+  - Return [ array ]
+}
diff --git a/Zend/tests/partial_application/rfc_examples_003.phpt b/Zend/tests/partial_application/rfc_examples_003.phpt
new file mode 100644
index 0000000000000..4462cf7c2f284
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_003.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Closure application RFC examples: errors
+--FILE--
+<?php
+
+if (time() > 0) {
+    function stuff(int $i, string $s, float $f, Point $p, int $m = 0) {}
+}
+
+try {
+    stuff(?);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    stuff(?, ?, ?, ?, ?, ?);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+try {
+    stuff(?, ?, 3.5, null, i: 5);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+
+?>
+--EXPECTF--
+not enough arguments or placeholders for application of stuff, 1 given and at least 4 expected
+too many arguments or placeholders for application of stuff, 6 given and a maximum of 5 expected
+Named parameter $i overwrites previous placeholder
diff --git a/Zend/tests/partial_application/rfc_examples_004.phpt b/Zend/tests/partial_application/rfc_examples_004.phpt
new file mode 100644
index 0000000000000..f07c7dc01550b
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_004.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application RFC examples: errors
+--FILE--
+<?php
+
+if (time() > 0) {
+    function stuff(int $i, string $s, float $f, Point $p, int $m = 0) {}
+}
+
+stuff(i:1, ?, ?, ?, ?);
+
+?>
+--EXPECTF--
+Fatal error: Cannot use positional argument after named argument in %s on line %d
diff --git a/Zend/tests/partial_application/rfc_examples_005.phpt b/Zend/tests/partial_application/rfc_examples_005.phpt
new file mode 100644
index 0000000000000..dbdffbe3a5356
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_005.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application RFC examples: errors
+--FILE--
+<?php
+
+if (time() > 0) {
+    function stuff(int $i, string $s, float $f, Point $p, int $m = 0) {}
+}
+
+stuff(?, ?, ?, p: $point, ?);
+
+?>
+--EXPECTF--
+Fatal error: Cannot use positional argument after named argument in %s on line %d
diff --git a/Zend/tests/partial_application/rfc_examples_006.phpt b/Zend/tests/partial_application/rfc_examples_006.phpt
new file mode 100644
index 0000000000000..ace55412e6fde
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_006.phpt
@@ -0,0 +1,29 @@
+--TEST--
+Closure application RFC examples: func_get_args()
+--FILE--
+<?php
+
+function f($a = 0, $b = 0, $c = 3, $d = 4) {
+    echo func_num_args() . PHP_EOL;
+
+    var_dump($a, $b, $c, $d);
+}
+
+f(1, 2);
+
+$f = f(?, ?);
+
+$f(1, 2);
+
+?>
+--EXPECT--
+2
+int(1)
+int(2)
+int(3)
+int(4)
+2
+int(1)
+int(2)
+int(3)
+int(4)
diff --git a/Zend/tests/partial_application/rfc_examples_007.phpt b/Zend/tests/partial_application/rfc_examples_007.phpt
new file mode 100644
index 0000000000000..acff4015d90d4
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_007.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Closure application RFC examples: evaluation order
+--FILE--
+<?php
+
+function getArg() {
+  print __FUNCTION__ . PHP_EOL;
+  return 'hi';
+}
+
+function speak(string $who, string $msg) {
+  printf("%s: %s\n", $who, $msg);
+}
+
+$arrow = fn($who) => speak($who, getArg());
+print "Arnaud\n";
+$arrow('Larry');
+
+$partial = speak(?, getArg());
+print "Arnaud\n";
+$partial('Larry');
+
+?>
+--EXPECT--
+Arnaud
+getArg
+Larry: hi
+getArg
+Arnaud
+Larry: hi
diff --git a/Zend/tests/partial_application/rfc_examples_008.phpt b/Zend/tests/partial_application/rfc_examples_008.phpt
new file mode 100644
index 0000000000000..7cc2ffd282733
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_008.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Closure application RFC examples: magic methods
+--FILE--
+<?php
+
+class Foo {
+    public function __call($method, $args) {
+        printf("%s::%s\n", __CLASS__, $method);
+        print_r($args);
+    }
+}
+
+$f = new Foo();
+$m = $f->method(?, ?);
+
+$m(1, 2);
+
+?>
+--EXPECTF--
+Foo::method
+Array
+(
+    [0] => 1
+    [1] => 2
+)
diff --git a/Zend/tests/partial_application/rfc_examples_009.phpt b/Zend/tests/partial_application/rfc_examples_009.phpt
new file mode 100644
index 0000000000000..00b00da54aba2
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_009.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Closure application RFC examples: unary function example
+--FILE--
+<?php
+
+$input = ['A', 'B', 'C', 'D'];
+$legal = ['a', 'B', 'c', 'D'];
+
+$result = array_map(in_array(?, $legal, strict: true), $input);
+
+var_dump($result);
+
+?>
+--EXPECT--
+array(4) {
+  [0]=>
+  bool(false)
+  [1]=>
+  bool(true)
+  [2]=>
+  bool(false)
+  [3]=>
+  bool(true)
+}
diff --git a/Zend/tests/partial_application/rfc_examples_010.phpt b/Zend/tests/partial_application/rfc_examples_010.phpt
new file mode 100644
index 0000000000000..fd488407395d4
--- /dev/null
+++ b/Zend/tests/partial_application/rfc_examples_010.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Closure application RFC examples: delayed execution
+--FILE--
+<?php
+
+class Point {}
+
+function expensive(int $a, int $b, Point $c) { return $c; }
+
+function some_condition() {
+    return true;
+}
+
+$default = expensive(3, 4, new Point, ...);
+
+if (some_condition()) {
+  $result = $default();
+  var_dump($result);
+}
+
+?>
+--EXPECTF--
+object(Point)#%d (0) {
+}
diff --git a/Zend/tests/partial_application/static_method_001.phpt b/Zend/tests/partial_application/static_method_001.phpt
new file mode 100644
index 0000000000000..cd7e8d33af515
--- /dev/null
+++ b/Zend/tests/partial_application/static_method_001.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Closure application static method
+--FILE--
+<?php
+class Foo {
+    public static function method($a, $b) {
+        printf("%s\n", __METHOD__);
+    }
+}
+
+$foo = Foo::method(new stdClass, ...);
+
+$bar = $foo(new stdClass, ...);
+
+$bar();
+?>
+--EXPECTF--
+Foo::method
diff --git a/Zend/tests/partial_application/statics_001.phpt b/Zend/tests/partial_application/statics_001.phpt
new file mode 100644
index 0000000000000..2465f938d7288
--- /dev/null
+++ b/Zend/tests/partial_application/statics_001.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Closure application static variables are shared
+--FILE--
+<?php
+function foo($a) {
+    static $var = 0;
+
+    ++$var;
+
+    return $var;
+}
+
+foo(new stdClass);
+
+$foo = foo(new stdClass, ...);
+
+if ($foo() == 2) {
+    echo "OK";
+}
+?>
+--EXPECTF--
+OK
diff --git a/Zend/tests/partial_application/statics_002.phpt b/Zend/tests/partial_application/statics_002.phpt
new file mode 100644
index 0000000000000..a1c2ad1f8702d
--- /dev/null
+++ b/Zend/tests/partial_application/statics_002.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Closure application static variables are shared
+--FILE--
+<?php
+$closure = function ($a) {
+    static $var = 0;
+
+    ++$var;
+
+    return $var;
+};
+
+$closure(new stdClass);
+
+$foo = $closure(new stdClass, ...);
+$closure = null;
+
+if ($foo() == 2) {
+    echo "OK";
+}
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/statics_003.phpt b/Zend/tests/partial_application/statics_003.phpt
new file mode 100644
index 0000000000000..b970dd84c0088
--- /dev/null
+++ b/Zend/tests/partial_application/statics_003.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Closure application static variables are shared
+--FILE--
+<?php
+$closure = function ($a) {
+    static $var = 0;
+
+    ++$var;
+
+    return $var;
+};
+
+$closure(new stdClass);
+
+$foo = $closure(?);
+$closure = null;
+
+$bar = $foo(?);
+$foo = null;
+
+if ($bar(new stdClass) == 2) {
+    echo "OK";
+}
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/superfluous_args_are_forwarded.phpt b/Zend/tests/partial_application/superfluous_args_are_forwarded.phpt
new file mode 100644
index 0000000000000..b7c99857d5ded
--- /dev/null
+++ b/Zend/tests/partial_application/superfluous_args_are_forwarded.phpt
@@ -0,0 +1,46 @@
+--TEST--
+PFAs forwarded superfluous args iff a '...' placeholder is specified
+--FILE--
+<?php
+
+function f($a) {
+    var_dump(func_get_args());
+}
+$f = f(?, ...);
+$f(1, 2, 3);
+
+function g($a,  ...$args) {
+    var_dump(func_get_args());
+}
+
+$g = f(?, ...);
+$g(1, 2, 3);
+
+function h($a) {
+}
+
+$h = f(?);
+$h(1, 2, 3);
+
+?>
+--EXPECT--
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(3) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+}
+array(1) {
+  [0]=>
+  int(1)
+}
diff --git a/Zend/tests/partial_application/this_001.phpt b/Zend/tests/partial_application/this_001.phpt
new file mode 100644
index 0000000000000..225c4f82a638f
--- /dev/null
+++ b/Zend/tests/partial_application/this_001.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Closure application this
+--FILE--
+<?php
+class Foo {
+    public function method($a, $b) {
+        return $this;
+    }
+}
+
+$foo = new Foo;
+
+$bar = $foo->method(new stdClass, ...);
+
+$baz = $bar(new stdClass, ...);
+
+var_dump($baz());
+?>
+--EXPECTF--
+object(Foo)#%d (0) {
+}
diff --git a/Zend/tests/partial_application/variation_call_001.phpt b/Zend/tests/partial_application/variation_call_001.phpt
new file mode 100644
index 0000000000000..4b72ecedacdf5
--- /dev/null
+++ b/Zend/tests/partial_application/variation_call_001.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Closure application variation call
+--FILE--
+<?php
+class Param {
+
+    public function __toString() {
+        return __CLASS__;
+    }
+}
+
+class Foo {
+    public function method($a, $b) {
+        printf("%s: %s, %s\n", get_called_class(), $a, $b);
+    }
+}
+
+class Bar extends Foo {
+
+}
+
+$bar = new Bar;
+$closure = $bar->method(?, new Param);
+
+$closure(1);
+
+$closure->call(new Foo(), 10);
+?>
+--EXPECT--
+Bar: 1, Param
+Foo: 10, Param
diff --git a/Zend/tests/partial_application/variation_closure_001.phpt b/Zend/tests/partial_application/variation_closure_001.phpt
new file mode 100644
index 0000000000000..069b7ef9067b7
--- /dev/null
+++ b/Zend/tests/partial_application/variation_closure_001.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Closure application variation closure
+--FILE--
+<?php
+$closure = function($a, $b) {
+
+};
+
+echo (string) new ReflectionFunction($closure(1, ?));
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 6 - 6
+
+  - Bound Variables [2] {
+      Variable #0 [ $a ]
+      Variable #1 [ $fn ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $b ]
+  }
+}
diff --git a/Zend/tests/partial_application/variation_closure_002.phpt b/Zend/tests/partial_application/variation_closure_002.phpt
new file mode 100644
index 0000000000000..fe2b36b4fd7ef
--- /dev/null
+++ b/Zend/tests/partial_application/variation_closure_002.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Closure application variation closure __invoke
+--FILE--
+<?php
+$closure = function($a, $b) {
+    var_dump($a, $b);
+};
+
+$function = $closure->__invoke(1, ?);
+
+echo (string) new ReflectionFunction($function);
+
+$function(10);
+?>
+--EXPECTF--
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %svariation_closure_002.php 6 - 6
+
+  - Bound Variables [1] {
+      Variable #0 [ $a ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $b ]
+  }
+}
+int(1)
+int(10)
diff --git a/Zend/tests/partial_application/variation_closure_003.phpt b/Zend/tests/partial_application/variation_closure_003.phpt
new file mode 100644
index 0000000000000..b962d56251b58
--- /dev/null
+++ b/Zend/tests/partial_application/variation_closure_003.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Closure application variation closure __invoke with this
+--FILE--
+<?php
+class Foo {
+    public function bar() {
+        return function($a, $b) {
+            return [$this, func_get_args()];
+        };
+    }
+}
+
+$foo = new Foo;
+
+$closure = $foo->bar();
+
+$function = $closure->__invoke(1, ?);
+
+echo (string) new ReflectionFunction($function);
+
+var_dump($function(10));
+?>
+--EXPECTF--
+Closure [ <user> public method {closure:%s:%d} ] {
+  @@ %svariation_closure_003.php 14 - 14
+
+  - Bound Variables [1] {
+      Variable #0 [ $a ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <required> $b ]
+  }
+}
+array(2) {
+  [0]=>
+  object(Foo)#1 (0) {
+  }
+  [1]=>
+  array(2) {
+    [0]=>
+    int(1)
+    [1]=>
+    int(10)
+  }
+}
diff --git a/Zend/tests/partial_application/variation_debug_001.phpt b/Zend/tests/partial_application/variation_debug_001.phpt
new file mode 100644
index 0000000000000..11ac69c615a82
--- /dev/null
+++ b/Zend/tests/partial_application/variation_debug_001.phpt
@@ -0,0 +1,40 @@
+--TEST--
+Closure application variation debug user
+--FILE--
+<?php
+function bar($a = 1, $b = 2, ...$c) {
+
+}
+
+var_dump(bar(?, new stdClass, 20, new stdClass, four: 4));
+?>
+--EXPECTF--
+object(Closure)#%d (5) {
+  ["name"]=>
+  string(%d) "{closure:%s}"
+  ["file"]=>
+  string(83) "%svariation_debug_001.php"
+  ["line"]=>
+  int(6)
+  ["static"]=>
+  array(4) {
+    ["b"]=>
+    object(stdClass)#%d (0) {
+    }
+    ["c"]=>
+    int(20)
+    ["c0"]=>
+    object(stdClass)#%d (0) {
+    }
+    ["extra_named_params"]=>
+    array(1) {
+      ["four"]=>
+      int(4)
+    }
+  }
+  ["parameter"]=>
+  array(1) {
+    ["$a"]=>
+    string(10) "<optional>"
+  }
+}
diff --git a/Zend/tests/partial_application/variation_debug_002.phpt b/Zend/tests/partial_application/variation_debug_002.phpt
new file mode 100644
index 0000000000000..e8adc3d015334
--- /dev/null
+++ b/Zend/tests/partial_application/variation_debug_002.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Closure application variation debug internal
+--FILE--
+<?php
+var_dump(array_map(?, [1,2,3], [4,5, 6], four: new stdClass, ...));
+?>
+--EXPECTF--
+object(Closure)#%d (5) {
+  ["name"]=>
+  string(%d) "{closure:%s}"
+  ["file"]=>
+  string(83) "%svariation_debug_002.php"
+  ["line"]=>
+  int(2)
+  ["static"]=>
+  array(3) {
+    ["array"]=>
+    array(3) {
+      [0]=>
+      int(1)
+      [1]=>
+      int(2)
+      [2]=>
+      int(3)
+    }
+    ["arrays0"]=>
+    array(3) {
+      [0]=>
+      int(4)
+      [1]=>
+      int(5)
+      [2]=>
+      int(6)
+    }
+    ["extra_named_params"]=>
+    array(1) {
+      ["four"]=>
+      object(stdClass)#%d (0) {
+      }
+    }
+  }
+  ["parameter"]=>
+  array(2) {
+    ["$callback"]=>
+    string(10) "<required>"
+    ["$arrays"]=>
+    string(10) "<optional>"
+  }
+}
diff --git a/Zend/tests/partial_application/variation_ex_001.phpt b/Zend/tests/partial_application/variation_ex_001.phpt
new file mode 100644
index 0000000000000..c2a69fb52017a
--- /dev/null
+++ b/Zend/tests/partial_application/variation_ex_001.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application variation uaf in cleanup unfinished calls
+--FILE--
+<?php
+function test($a){}
+
+try {
+    test(1,...)(?);
+} catch (Error $ex) {
+    echo "OK";
+}
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_gc_001.phpt b/Zend/tests/partial_application/variation_gc_001.phpt
new file mode 100644
index 0000000000000..1bc78bfea4d48
--- /dev/null
+++ b/Zend/tests/partial_application/variation_gc_001.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Closure application variation GC
+--FILE--
+<?php
+#[AllowDynamicProperties]
+class Foo {
+
+  public function __construct($a) {
+    $this->method = self::__construct(new stdClass, ...);
+  }
+}
+
+$foo = new Foo(new stdClass);
+$foo->bar = $foo;
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_gc_002.phpt b/Zend/tests/partial_application/variation_gc_002.phpt
new file mode 100644
index 0000000000000..becfc4ef26943
--- /dev/null
+++ b/Zend/tests/partial_application/variation_gc_002.phpt
@@ -0,0 +1,11 @@
+--TEST--
+Closure application variation GC
+--FILE--
+<?php
+$obj = new stdClass;
+$obj->prop = var_dump($obj, ?);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_gc_003.phpt b/Zend/tests/partial_application/variation_gc_003.phpt
new file mode 100644
index 0000000000000..ef5d4904e6e8c
--- /dev/null
+++ b/Zend/tests/partial_application/variation_gc_003.phpt
@@ -0,0 +1,15 @@
+--TEST--
+Closure application variation GC
+--FILE--
+<?php
+  
+function test(...$args) {
+}
+
+$obj = new stdClass;
+$obj->prop = test(?, x: $obj);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_invoke_001.phpt b/Zend/tests/partial_application/variation_invoke_001.phpt
new file mode 100644
index 0000000000000..dfbbe39c40c50
--- /dev/null
+++ b/Zend/tests/partial_application/variation_invoke_001.phpt
@@ -0,0 +1,23 @@
+--TEST--
+Closure application variation __invoke
+--FILE--
+<?php
+function foo($a, $b) {
+    return $a + $b;
+}
+
+$foo = foo(b: 10, ...);
+
+if ($foo->__invoke(32) == 42) {
+    echo "OK\n";
+}
+
+try {
+    $foo->nothing();
+} catch (Error $ex) {
+    echo "OK";
+}
+?>
+--EXPECT--
+OK
+OK
diff --git a/Zend/tests/partial_application/variation_nocall_001.phpt b/Zend/tests/partial_application/variation_nocall_001.phpt
new file mode 100644
index 0000000000000..6815f9764e422
--- /dev/null
+++ b/Zend/tests/partial_application/variation_nocall_001.phpt
@@ -0,0 +1,12 @@
+--TEST--
+Closure application variation no call args leak
+--FILE--
+<?php
+function test($a, $b) {}
+
+test(?, new stdClass);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_nocall_002.phpt b/Zend/tests/partial_application/variation_nocall_002.phpt
new file mode 100644
index 0000000000000..d94c4ef68a186
--- /dev/null
+++ b/Zend/tests/partial_application/variation_nocall_002.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application variation no call order of destruction
+--FILE--
+<?php
+class Foo {
+    function method($a, $b) {}
+}
+$foo = new Foo;
+$foo->method(new stdClass, ...)(new stdClass, ...);
+
+echo "OK";
+?>
+--EXPECT--
+OK
diff --git a/Zend/tests/partial_application/variation_parent_001.phpt b/Zend/tests/partial_application/variation_parent_001.phpt
new file mode 100644
index 0000000000000..77261fba74977
--- /dev/null
+++ b/Zend/tests/partial_application/variation_parent_001.phpt
@@ -0,0 +1,75 @@
+--TEST--
+Closure application variation parent
+--FILE--
+<?php
+class Foo {
+    public function method($a, $b, ...$c) {
+        return function() {
+            return $this;
+        };
+    }
+}
+
+$foo = new Foo();
+$bar = $foo->method(10, ...);
+$baz = $bar(20, ...);
+
+var_dump($baz, $baz());
+?>
+--EXPECTF--
+object(Closure)#%d (6) {
+  ["name"]=>
+  string(%d) "{closure:%s}"
+  ["file"]=>
+  string(84) "%svariation_parent_001.php"
+  ["line"]=>
+  int(12)
+  ["static"]=>
+  array(2) {
+    ["b"]=>
+    int(20)
+    ["fn"]=>
+    object(Closure)#%d (6) {
+      ["name"]=>
+      string(%d) "{closure:%s:%d}"
+      ["file"]=>
+      string(%d) "%s"
+      ["line"]=>
+      int(11)
+      ["static"]=>
+      array(1) {
+        ["a"]=>
+        int(10)
+      }
+      ["this"]=>
+      object(Foo)#%d (0) {
+      }
+      ["parameter"]=>
+      array(2) {
+        ["$b"]=>
+        string(10) "<required>"
+        ["$c"]=>
+        string(10) "<optional>"
+      }
+    }
+  }
+  ["this"]=>
+  object(Foo)#%d (0) {
+  }
+  ["parameter"]=>
+  array(1) {
+    ["$c"]=>
+    string(10) "<optional>"
+  }
+}
+object(Closure)#%d (4) {
+  ["name"]=>
+  string(25) "{closure:Foo::method():4}"
+  ["file"]=>
+  string(84) "%s"
+  ["line"]=>
+  int(4)
+  ["this"]=>
+  object(Foo)#%d (0) {
+  }
+}
diff --git a/Zend/tests/partial_application/variation_scope_001.phpt b/Zend/tests/partial_application/variation_scope_001.phpt
new file mode 100644
index 0000000000000..0e63e554c3c52
--- /dev/null
+++ b/Zend/tests/partial_application/variation_scope_001.phpt
@@ -0,0 +1,18 @@
+--TEST--
+Closure application variation called scope
+--FILE--
+<?php
+class Foo {
+    public function method($a) {
+        printf("%s::%s\n", get_called_class(), __FUNCTION__);
+    }
+}
+
+$foo = new Foo;
+
+$bar = $foo->method(new stdClass, ...);
+
+$bar();
+?>
+--EXPECT--
+Foo::method
diff --git a/Zend/tests/partial_application/variation_strict_001.phpt b/Zend/tests/partial_application/variation_strict_001.phpt
new file mode 100644
index 0000000000000..2c447d229811a
--- /dev/null
+++ b/Zend/tests/partial_application/variation_strict_001.phpt
@@ -0,0 +1,20 @@
+--TEST--
+Closure application variation: strict_types declared
+--FILE--
+<?php
+declare(strict_types=1);
+
+function foo(int $int) {
+    var_dump($int);
+}
+
+$foo = foo(?);
+
+try {
+    $foo("42");
+} catch (TypeError $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+?>
+--EXPECTF--
+TypeError: {closure:%s:%d}(): Argument #1 ($int) must be of type int, string given, called in %s on line %d
diff --git a/Zend/tests/partial_application/variation_variadics_001.phpt b/Zend/tests/partial_application/variation_variadics_001.phpt
new file mode 100644
index 0000000000000..0fa703d6ac8ee
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_001.phpt
@@ -0,0 +1,31 @@
+--TEST--
+Closure application variation variadics user
+--FILE--
+<?php
+function foo($a, ...$b) {
+    var_dump($a, ...$b);
+}
+
+$foo = foo(10, 100, ...);
+
+echo (string) new ReflectionFunction($foo);
+
+$foo(1000, 10000);
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %s 6 - 6
+
+  - Bound Variables [2] {
+      Variable #0 [ $a ]
+      Variable #1 [ $b0 ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> ...$b ]
+  }
+}
+int(10)
+int(100)
+int(1000)
+int(10000)
diff --git a/Zend/tests/partial_application/variation_variadics_002.phpt b/Zend/tests/partial_application/variation_variadics_002.phpt
new file mode 100644
index 0000000000000..4eb767a4b3a9b
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_002.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Closure application variation variadics internal
+--FILE--
+<?php
+$sprintf = sprintf("%d %d %d", 100, ...);
+
+echo (string) new ReflectionFunction($sprintf);
+
+echo $sprintf(1000, 10000);
+?>
+--EXPECTF--
+Closure [ <user> static function {closure:%s:%d} ] {
+  @@ %svariation_variadics_002.php 2 - 2
+
+  - Bound Variables [2] {
+      Variable #0 [ $format ]
+      Variable #1 [ $values0 ]
+  }
+
+  - Parameters [1] {
+    Parameter #0 [ <optional> mixed ...$values ]
+  }
+  - Return [ string ]
+}
+100 1000 10000
diff --git a/Zend/tests/partial_application/variation_variadics_003.phpt b/Zend/tests/partial_application/variation_variadics_003.phpt
new file mode 100644
index 0000000000000..cc298836c8b28
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_003.phpt
@@ -0,0 +1,60 @@
+--TEST--
+Closure application variation variadics interactions
+--XFAIL--
+TODO: extra args rules
+--FILE--
+<?php
+function foo($a, $b) {
+    var_dump(func_get_args());
+}
+
+$foo = foo(?, ?);
+
+try {
+    $foo(1, 2, 3); // FAIL, 2 expected, 3 given
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+try {
+    $foo = foo(?, ?, ?); // FAIL 2 expected, 3 given
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+function bar($a, $b, ...$c) {
+    var_dump(func_get_args());
+}
+
+$bar = bar(?, ?);
+
+try {
+    $bar(1, 2, 3); // FAIL 3 given, maximum 2 expected
+} catch (Error $ex) {
+    printf("%s: %s\n", $ex::class, $ex->getMessage());
+}
+
+$foo = foo(?, ?, ...);
+
+$foo(1, 2, 3); // OK
+?>
+--EXPECT--
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+Error: too many arguments or placeholders for application of foo, 3 given and a maximum of 2 expected
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+}
diff --git a/Zend/tests/partial_application/variation_variadics_004.phpt b/Zend/tests/partial_application/variation_variadics_004.phpt
new file mode 100644
index 0000000000000..9fa53a2eeab80
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_004.phpt
@@ -0,0 +1,65 @@
+--TEST--
+Closure application variation variadics and optional args
+--FILE--
+<?php
+function foo(int $day = 1, int $month = 1, int $year = 2005) {
+    return ["day" => $day, "month" => $month, "year" => $year];
+}
+
+$foo = foo(year: 2006, ...);
+
+var_dump($foo(2));
+
+$foo = foo(month: 12, ...);
+
+$bar = $foo(year: 2016, ...);
+
+var_dump($foo(2));
+
+var_dump($bar(2));
+
+var_dump($foo());
+
+var_dump($bar());
+?>
+--EXPECTF--
+array(3) {
+  ["day"]=>
+  int(2)
+  ["month"]=>
+  int(1)
+  ["year"]=>
+  int(2006)
+}
+array(3) {
+  ["day"]=>
+  int(2)
+  ["month"]=>
+  int(12)
+  ["year"]=>
+  int(2005)
+}
+array(3) {
+  ["day"]=>
+  int(2)
+  ["month"]=>
+  int(12)
+  ["year"]=>
+  int(2016)
+}
+array(3) {
+  ["day"]=>
+  int(1)
+  ["month"]=>
+  int(12)
+  ["year"]=>
+  int(2005)
+}
+array(3) {
+  ["day"]=>
+  int(1)
+  ["month"]=>
+  int(12)
+  ["year"]=>
+  int(2016)
+}
diff --git a/Zend/tests/partial_application/variation_variadics_006.phpt b/Zend/tests/partial_application/variation_variadics_006.phpt
new file mode 100644
index 0000000000000..b0dba19434b7c
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_006.phpt
@@ -0,0 +1,17 @@
+--TEST--
+Closure application variation named may overwrite variadic placeholder
+--FILE--
+<?php
+function foo($a) {
+    var_dump(func_get_args());
+}
+
+$foo = foo(a: "a", ...);
+
+$foo();
+?>
+--EXPECTF--
+array(1) {
+  [0]=>
+  string(1) "a"
+}
diff --git a/Zend/tests/partial_application/variation_variadics_007.phpt b/Zend/tests/partial_application/variation_variadics_007.phpt
new file mode 100644
index 0000000000000..7548c504935c7
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_007.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Closure application variation extra through variadic
+--FILE--
+<?php
+function appliesCb($cb) { return runsCb($cb(1, ?, ...)); }
+
+function runsCb($cb) {
+        return $cb(2, 3);
+} 
+
+var_dump(appliesCb(fn($a, $b) => $a + $b));
+?>
+--EXPECT--
+int(3)
diff --git a/Zend/tests/partial_application/variation_variadics_008.phpt b/Zend/tests/partial_application/variation_variadics_008.phpt
new file mode 100644
index 0000000000000..0c221dbe1b19a
--- /dev/null
+++ b/Zend/tests/partial_application/variation_variadics_008.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Closure application variation variadics wrong signature checked
+--FILE--
+<?php
+function foo(...$c) {}
+
+$fn = foo(?);
+
+try {
+    $fn(?, ?);
+} catch (Error $ex) {
+    echo $ex->getMessage() . PHP_EOL;
+}
+?>
+--EXPECTF--
+too many arguments or placeholders for application of {closure:%s}, 2 given and a maximum of 1 expected
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 9cb3c7aae4a1f..5328bb36e3948 100644
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -61,6 +61,7 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_fcc(void) {
 	ast->kind = ZEND_AST_CALLABLE_CONVERT;
 	ast->attr = 0;
 	ast->lineno = CG(zend_lineno);
+	ast->args = NULL;
 	ZEND_MAP_PTR_INIT(ast->fptr, NULL);
 
 	return (zend_ast *) ast;
@@ -157,6 +158,12 @@ ZEND_API zend_ast *zend_ast_create_decl(
 	return (zend_ast *) ast;
 }
 
+static bool zend_ast_is_placeholder_arg(zend_ast *arg) {
+	return arg->kind == ZEND_AST_PLACEHOLDER_ARG
+		|| (arg->kind == ZEND_AST_NAMED_ARG
+				&& arg->child[1]->kind == ZEND_AST_PLACEHOLDER_ARG);
+}
+
 #if ZEND_AST_SPEC
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_0(zend_ast_kind kind) {
 	zend_ast *ast;
@@ -400,6 +407,34 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_2(zend_ast_kind kind, zen
 
 	return ast;
 }
+
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_0(zend_ast_kind kind) {
+	return zend_ast_create_list(0, kind);
+}
+
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_1(zend_ast_kind kind, zend_ast *arg) {
+	zend_ast *list = zend_ast_create_list(1, kind, arg);
+
+	if (zend_ast_is_placeholder_arg(arg)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = list;
+		return (zend_ast*)fcc_ast;
+	}
+
+	return list;
+}
+
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_2(zend_ast_kind kind, zend_ast *arg1, zend_ast *arg2) {
+	zend_ast *list = zend_ast_create_list(2, kind, arg1, arg2);
+
+	if (zend_ast_is_placeholder_arg(arg1) || zend_ast_is_placeholder_arg(arg2)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = list;
+		return (zend_ast*)fcc_ast;
+	}
+
+	return list;
+}
 #else
 static zend_ast *zend_ast_create_from_va_list(zend_ast_kind kind, zend_ast_attr attr, va_list va) {
 	uint32_t i, children = kind >> ZEND_AST_NUM_CHILDREN_SHIFT;
@@ -479,6 +514,43 @@ ZEND_API zend_ast *zend_ast_create_list(uint32_t init_children, zend_ast_kind ki
 
 	return ast;
 }
+
+ZEND_API zend_ast *zend_ast_create_arg_list(uint32_t init_children, zend_ast_kind kind, ...) {
+	zend_ast *ast;
+	zend_ast_list *list;
+	bool has_placeholders = false;
+
+	ast = zend_ast_alloc(zend_ast_list_size(4));
+	list = (zend_ast_list *) ast;
+	list->kind = kind;
+	list->attr = 0;
+	list->lineno = CG(zend_lineno);
+	list->children = 0;
+
+	{
+		va_list va;
+		uint32_t i;
+		va_start(va, kind);
+		for (i = 0; i < init_children; ++i) {
+			zend_ast *child = va_arg(va, zend_ast *);
+			ast = zend_ast_list_add(ast, child);
+			uint32_t lineno = zend_ast_get_lineno(child);
+			if (lineno < ast->lineno) {
+				ast->lineno = lineno;
+			}
+			has_placeholders = has_placeholders || zend_ast_is_placeholder_arg(child);
+		}
+		va_end(va);
+	}
+
+	if (has_placeholders) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = ast;
+		return (zend_ast*)fcc_ast;
+	}
+
+	return ast;
+}
 #endif
 
 zend_ast *zend_ast_create_concat_op(zend_ast *op0, zend_ast *op1) {
@@ -508,6 +580,25 @@ ZEND_ATTRIBUTE_NODISCARD ZEND_API zend_ast * ZEND_FASTCALL zend_ast_list_add(zen
 	return (zend_ast *) list;
 }
 
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_arg_list_add(zend_ast *list, zend_ast *arg)
+{
+	if (list->kind == ZEND_AST_CALLABLE_CONVERT) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)list;
+		fcc_ast->args = zend_ast_list_add(fcc_ast->args, arg);
+		return (zend_ast*)fcc_ast;
+	}
+
+	ZEND_ASSERT(list->kind == ZEND_AST_ARG_LIST);
+
+	if (zend_ast_is_placeholder_arg(arg)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)zend_ast_create_fcc();
+		fcc_ast->args = zend_ast_list_add(list, arg);
+		return (zend_ast*)fcc_ast;
+	}
+
+	return zend_ast_list_add(list, arg);
+}
+
 static zend_result zend_ast_add_array_element(const zval *result, zval *offset, zval *expr)
 {
 	if (Z_TYPE_P(offset) == IS_UNDEF) {
@@ -1060,6 +1151,14 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 				case ZEND_AST_CALL: {
 					ZEND_ASSERT(ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT);
 					zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast->child[1];
+
+					zend_ast_list *args = zend_ast_get_list(fcc_ast->args);
+					ZEND_ASSERT(args->children > 0);
+					if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+						/* TODO: PFAs */
+						return FAILURE;
+					}
+
 					fptr = ZEND_MAP_PTR_GET(fcc_ast->fptr);
 
 					if (!fptr) {
@@ -1087,6 +1186,13 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 					ZEND_ASSERT(ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT);
 					zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast->child[2];
 
+					zend_ast_list *args = zend_ast_get_list(fcc_ast->args);
+					ZEND_ASSERT(args->children > 0);
+					if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+						/* TODO: PFAs */
+						return FAILURE;
+					}
+
 					zend_class_entry *ce = zend_ast_fetch_class(ast->child[0], scope);
 					if (!ce) {
 						return FAILURE;
@@ -1124,12 +1230,12 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_inner(
 
 						if (!(fptr->common.fn_flags & ZEND_ACC_STATIC)) {
 							zend_non_static_method_call(fptr);
-							
+
 							return FAILURE;
 						}
 						if ((fptr->common.fn_flags & ZEND_ACC_ABSTRACT)) {
 							zend_abstract_method_call(fptr);
-							
+
 							return FAILURE;
 						} else if (fptr->common.scope->ce_flags & ZEND_ACC_TRAIT) {
 							zend_error(E_DEPRECATED,
@@ -1243,7 +1349,8 @@ static size_t ZEND_FASTCALL zend_ast_tree_size(zend_ast *ast)
 	} else if (ast->kind == ZEND_AST_OP_ARRAY) {
 		size = sizeof(zend_ast_op_array);
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
-		size = sizeof(zend_ast_fcc);
+		zend_ast *args_ast = ((zend_ast_fcc*)ast)->args;
+		size = sizeof(zend_ast_fcc) + zend_ast_tree_size(args_ast);
 	} else if (zend_ast_is_list(ast)) {
 		uint32_t i;
 		const zend_ast_list *list = zend_ast_get_list(ast);
@@ -1320,6 +1427,8 @@ static void* ZEND_FASTCALL zend_ast_tree_copy(zend_ast *ast, void *buf)
 		new->lineno = old->lineno;
 		ZEND_MAP_PTR_INIT(new->fptr, ZEND_MAP_PTR(old->fptr));
 		buf = (void*)((char*)buf + sizeof(zend_ast_fcc));
+		new->args = buf;
+		buf = zend_ast_tree_copy(old->args, buf);
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
 		ZEND_UNREACHABLE();
@@ -1356,6 +1465,16 @@ ZEND_API zend_ast_ref * ZEND_FASTCALL zend_ast_copy(zend_ast *ast)
 	return ref;
 }
 
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_dup(zend_ast *ast)
+{
+	ZEND_ASSERT(ast != NULL);
+
+	void *buf = zend_ast_alloc(zend_ast_tree_size(ast));
+	zend_ast_tree_copy(ast, buf);
+
+	return (zend_ast*)buf;
+}
+
 ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 {
 tail_call:
@@ -1403,6 +1522,10 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 		zend_ast_destroy(decl->child[3]);
 		ast = decl->child[4];
 		goto tail_call;
+	} else if (EXPECTED(ast->kind == ZEND_AST_CALLABLE_CONVERT)) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*) ast;
+
+		zend_ast_destroy(fcc_ast->args);
 	}
 }
 
@@ -2299,6 +2422,13 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio
 				EMPTY_SWITCH_DEFAULT_CASE();
 			}
 			break;
+		case ZEND_AST_PLACEHOLDER_ARG:
+			if (ast->attr == _IS_PLACEHOLDER_ARG) {
+				APPEND_STR("?");
+			} else if (ast->attr == _IS_PLACEHOLDER_VARIADIC) {
+				APPEND_STR("...");
+			}
+			break;
 
 		/* 1 child node */
 		case ZEND_AST_VAR:
@@ -2445,9 +2575,10 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio
 			zend_ast_export_ex(str, ast->child[1], 0, indent);
 			smart_str_appendc(str, ')');
 			break;
-		case ZEND_AST_CALLABLE_CONVERT:
-			smart_str_appends(str, "...");
-			break;
+		case ZEND_AST_CALLABLE_CONVERT:;
+			zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast;
+			ast = fcc_ast->args;
+			goto simple_list;
 		case ZEND_AST_CLASS_CONST:
 			zend_ast_export_ns_name(str, ast->child[0], 0, indent);
 			smart_str_appends(str, "::");
@@ -2966,3 +3097,14 @@ zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr)
 
 	return ast;
 }
+
+zend_ast * ZEND_FASTCALL zend_ast_call_get_args(zend_ast *ast)
+{
+	if (ast->kind == ZEND_AST_CALL) {
+		return ast->child[1];
+	} else if (ast->kind == ZEND_AST_STATIC_CALL || ast->kind == ZEND_AST_METHOD_CALL) {
+		return ast->child[2];
+	}
+
+	return NULL;
+}
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index fb48b187252b3..cf3af4977b2a1 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -76,6 +76,7 @@ enum _zend_ast_kind {
 	ZEND_AST_TYPE,
 	ZEND_AST_CONSTANT_CLASS,
 	ZEND_AST_CALLABLE_CONVERT,
+	ZEND_AST_PLACEHOLDER_ARG,
 
 	/* 1 child node */
 	ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT,
@@ -229,10 +230,12 @@ typedef struct _zend_ast_decl {
 	zend_ast *child[5];
 } zend_ast_decl;
 
+// TODO: rename
 typedef struct _zend_ast_fcc {
 	zend_ast_kind kind; /* Type of the node (ZEND_AST_* enum constant) */
 	zend_ast_attr attr; /* Additional attribute, use depending on node type */
 	uint32_t lineno;    /* Line number */
+	zend_ast *args;
 	ZEND_MAP_PTR_DEF(zend_function *, fptr);
 } zend_ast_fcc;
 
@@ -307,21 +310,33 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_0(zend_ast_kind kind);
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_1(zend_ast_kind kind, zend_ast *child);
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_list_2(zend_ast_kind kind, zend_ast *child1, zend_ast *child2);
 
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_0(zend_ast_kind kind);
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_1(zend_ast_kind kind, zend_ast *child);
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_arg_list_2(zend_ast_kind kind, zend_ast *child1, zend_ast *child2);
+
 # define zend_ast_create(...) \
 	ZEND_AST_SPEC_CALL(zend_ast_create, __VA_ARGS__)
 # define zend_ast_create_ex(...) \
 	ZEND_AST_SPEC_CALL_EX(zend_ast_create_ex, __VA_ARGS__)
 # define zend_ast_create_list(init_children, ...) \
 	ZEND_AST_SPEC_CALL(zend_ast_create_list, __VA_ARGS__)
+# define zend_ast_create_arg_list(init_children, ...) \
+	ZEND_AST_SPEC_CALL(zend_ast_create_arg_list, __VA_ARGS__)
 
 #else
 ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...);
 ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...);
 ZEND_API zend_ast *zend_ast_create_list(uint32_t init_children, zend_ast_kind kind, ...);
+ZEND_API zend_ast *zend_ast_create_arg_list(uint32_t init_children, zend_ast_kind kind, ...);
 #endif
 
 ZEND_ATTRIBUTE_NODISCARD ZEND_API zend_ast * ZEND_FASTCALL zend_ast_list_add(zend_ast *list, zend_ast *op);
 
+/* Like zend_ast_list_add(), but wraps the list into a ZEND_AST_CALLABLE_CONVERT
+ * if any arg is a ZEND_AST_PLACEHOLDER_ARG. list can be a zend_ast_list, or a
+ * zend_ast_fcc. */
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_arg_list_add(zend_ast *list, zend_ast *arg);
+
 ZEND_API zend_ast *zend_ast_create_decl(
 	zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
 	zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4
@@ -338,6 +353,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_ast_evaluate_ex(zval *result, zend_ast *
 ZEND_API zend_string *zend_ast_export(const char *prefix, zend_ast *ast, const char *suffix);
 
 ZEND_API zend_ast_ref * ZEND_FASTCALL zend_ast_copy(zend_ast *ast);
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_dup(zend_ast *ast);
 ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast);
 ZEND_API void ZEND_FASTCALL zend_ast_ref_destroy(zend_ast_ref *ast);
 
@@ -425,4 +441,6 @@ static zend_always_inline zend_ast *zend_ast_list_rtrim(zend_ast *ast) {
 
 zend_ast * ZEND_FASTCALL zend_ast_with_attributes(zend_ast *ast, zend_ast *attr);
 
+zend_ast * ZEND_FASTCALL zend_ast_call_get_args(zend_ast *ast);
+
 #endif
diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index 22fd30463726f..5a230ebe32521 100644
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -28,6 +28,11 @@
 #include "zend_globals.h"
 #include "zend_closures_arginfo.h"
 
+#define ZEND_CLOSURE_PARTIAL OBJ_EXTRA_FLAG_PRIV_1
+
+#define ZEND_CLOSURE_FLAGS(closure)   ((closure)->std.extra_flags & ZEND_CLOSURE_PARTIAL)
+#define ZEND_CLOSURE_IS_FAKE(closure) ((closure)->func.common.fn_flags & ZEND_ACC_FAKE_CLOSURE)
+
 typedef struct _zend_closure {
 	zend_object       std;
 	zend_function     func;
@@ -41,6 +46,7 @@ ZEND_API zend_class_entry *zend_ce_closure;
 static zend_object_handlers closure_handlers;
 
 static zend_result zend_closure_get_closure(zend_object *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr, bool check_only);
+static void zend_create_closure_ex(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr, bool is_fake, uint32_t flags);
 
 ZEND_METHOD(Closure, __invoke) /* {{{ */
 {
@@ -78,7 +84,8 @@ static bool zend_valid_closure_binding(
 		zend_closure *closure, zval *newthis, zend_class_entry *scope) /* {{{ */
 {
 	zend_function *func = &closure->func;
-	bool is_fake_closure = (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) != 0;
+	bool is_fake_closure = (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) != 0
+		|| (closure->std.extra_flags & ZEND_CLOSURE_PARTIAL);
 	if (newthis) {
 		if (func->common.fn_flags & ZEND_ACC_STATIC) {
 			zend_error(E_WARNING, "Cannot bind an instance to a static closure, this will be an error in PHP 9");
@@ -161,7 +168,9 @@ ZEND_METHOD(Closure, call)
 
 	if (closure->func.common.fn_flags & ZEND_ACC_GENERATOR) {
 		zval new_closure;
-		zend_create_closure(&new_closure, &closure->func, newclass, closure->called_scope, newthis);
+		zend_create_closure_ex(&new_closure, &closure->func, newclass,
+				closure->called_scope, newthis,
+				ZEND_CLOSURE_IS_FAKE(closure), ZEND_CLOSURE_FLAGS(closure));
 		closure = (zend_closure *) Z_OBJ(new_closure);
 		fci_cache.function_handler = &closure->func;
 
@@ -177,6 +186,7 @@ ZEND_METHOD(Closure, call)
 		memset(&fake_closure->std, 0, sizeof(fake_closure->std));
 		fake_closure->std.gc.refcount = 1;
 		fake_closure->std.gc.u.type_info = GC_NULL;
+		fake_closure->std.extra_flags = ZEND_CLOSURE_FLAGS(closure);
 		ZVAL_UNDEF(&fake_closure->this_ptr);
 		fake_closure->called_scope = NULL;
 		my_function = &fake_closure->func;
@@ -251,7 +261,8 @@ static void do_closure_bind(zval *return_value, zval *zclosure, zval *newthis, z
 		called_scope = ce;
 	}
 
-	zend_create_closure(return_value, &closure->func, ce, called_scope, newthis);
+	zend_create_closure_ex(return_value, &closure->func, ce, called_scope, newthis,
+		ZEND_CLOSURE_IS_FAKE(closure), ZEND_CLOSURE_FLAGS(closure));
 }
 
 /* {{{ Create a closure from another one and bind to another object and scope */
@@ -575,8 +586,9 @@ static zend_object *zend_closure_clone(zend_object *zobject) /* {{{ */
 	zend_closure *closure = (zend_closure *)zobject;
 	zval result;
 
-	zend_create_closure(&result, &closure->func,
-		closure->func.common.scope, closure->called_scope, &closure->this_ptr);
+	zend_create_closure_ex(&result, &closure->func,
+		closure->func.common.scope, closure->called_scope, &closure->this_ptr,
+		ZEND_CLOSURE_IS_FAKE(closure), ZEND_CLOSURE_FLAGS(closure));
 	return Z_OBJ(result);
 }
 /* }}} */
@@ -750,7 +762,7 @@ static ZEND_NAMED_FUNCTION(zend_closure_internal_handler) /* {{{ */
 }
 /* }}} */
 
-static void zend_create_closure_ex(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr, bool is_fake) /* {{{ */
+static void zend_create_closure_ex(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr, bool is_fake, uint32_t flags) /* {{{ */
 {
 	zend_closure *closure;
 	void *ptr;
@@ -758,6 +770,7 @@ static void zend_create_closure_ex(zval *res, zend_function *func, zend_class_en
 	object_init_ex(res, zend_ce_closure);
 
 	closure = (zend_closure *)Z_OBJ_P(res);
+	closure->std.extra_flags = flags;
 
 	if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {
 		/* use dummy scope if we're binding an object without specifying a scope */
@@ -855,20 +868,26 @@ static void zend_create_closure_ex(zval *res, zend_function *func, zend_class_en
 ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr)
 {
 	zend_create_closure_ex(res, func, scope, called_scope, this_ptr,
-		/* is_fake */ (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) != 0);
+		/* is_fake */ (func->common.fn_flags & ZEND_ACC_FAKE_CLOSURE) != 0, 0);
 }
 
 ZEND_API void zend_create_fake_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr) /* {{{ */
 {
 	zend_closure *closure;
 
-	zend_create_closure_ex(res, func, scope, called_scope, this_ptr, /* is_fake */ true);
+	zend_create_closure_ex(res, func, scope, called_scope, this_ptr, /* is_fake */ true, 0);
 
 	closure = (zend_closure *)Z_OBJ_P(res);
 	closure->func.common.fn_flags |= ZEND_ACC_FAKE_CLOSURE;
 }
 /* }}} */
 
+ZEND_API void zend_create_partial_closure(zval *res, zend_function *func, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr)
+{
+	zend_create_closure_ex(res, func, scope, called_scope, this_ptr,
+			/* is_fake */ false, ZEND_CLOSURE_PARTIAL);
+}
+
 /* __call and __callStatic name the arguments "$arguments" in the docs. */
 static zend_internal_arg_info trampoline_arg_info[] = {ZEND_ARG_VARIADIC_TYPE_INFO(false, arguments, IS_MIXED, false)};
 
diff --git a/Zend/zend_closures.h b/Zend/zend_closures.h
index ced1b5ba48c15..73f7120920f9c 100644
--- a/Zend/zend_closures.h
+++ b/Zend/zend_closures.h
@@ -37,6 +37,7 @@ extern ZEND_API zend_class_entry *zend_ce_closure;
 
 ZEND_API void zend_create_closure(zval *res, zend_function *op_array, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr);
 ZEND_API void zend_create_fake_closure(zval *res, zend_function *op_array, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr);
+ZEND_API void zend_create_partial_closure(zval *res, zend_function *op_array, zend_class_entry *scope, zend_class_entry *called_scope, zval *this_ptr);
 ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *obj);
 ZEND_API const zend_function *zend_get_closure_method_def(zend_object *obj);
 ZEND_API zval* zend_get_closure_this_ptr(zval *obj);
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index aca73dbcc86d0..21b7b969fb5fc 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -28,6 +28,8 @@
 #include "zend_API.h"
 #include "zend_exceptions.h"
 #include "zend_interfaces.h"
+#include "zend_portability.h"
+#include "zend_string.h"
 #include "zend_virtual_cwd.h"
 #include "zend_multibyte.h"
 #include "zend_language_scanner.h"
@@ -3712,11 +3714,13 @@ static uint32_t zend_get_arg_num(zend_function *fn, zend_string *arg_name) {
 }
 
 static uint32_t zend_compile_args(
-		zend_ast *ast, zend_function *fbc, bool *may_have_extra_named_args) /* {{{ */
+		zend_ast *ast, zend_function *fbc, bool is_call_partial,
+		bool *may_have_extra_named_args) /* {{{ */
 {
 	zend_ast_list *args = zend_ast_get_list(ast);
 	uint32_t i;
 	bool uses_arg_unpack = 0;
+	bool uses_variadic_placeholder = 0;
 	uint32_t arg_count = 0; /* number of arguments not including unpacks */
 
 	/* Whether named arguments are used syntactically, to enforce language level limitations.
@@ -3742,6 +3746,11 @@ static uint32_t zend_compile_args(
 					"Cannot use argument unpacking after named arguments");
 			}
 
+			if (is_call_partial) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot combine partial application and unpacking");
+			}
+
 			/* Unpack may contain named arguments. */
 			may_have_undef = 1;
 			if (!fbc || (fbc->common.fn_flags & ZEND_ACC_VARIADIC)) {
@@ -3782,18 +3791,66 @@ static uint32_t zend_compile_args(
 				may_have_undef = 1;
 				*may_have_extra_named_args = 1;
 			}
+
+			if (uses_variadic_placeholder) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Variadic placeholder must be last");
+			}
 		} else {
 			if (uses_arg_unpack) {
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Cannot use positional argument after argument unpacking");
 			}
 
-			if (uses_named_args) {
+			if (uses_named_args
+					&& (arg->kind != ZEND_AST_PLACEHOLDER_ARG
+						|| arg->attr != _IS_PLACEHOLDER_VARIADIC)) {
 				zend_error_noreturn(E_COMPILE_ERROR,
 					"Cannot use positional argument after named argument");
 			}
 
-			arg_count++;
+			if (uses_variadic_placeholder) {
+				if (arg->kind == ZEND_AST_PLACEHOLDER_ARG
+						&& arg->attr == _IS_PLACEHOLDER_VARIADIC) {
+					zend_error_noreturn(E_COMPILE_ERROR,
+						"Variadic placeholder may only appear once");
+				} else {
+					zend_error_noreturn(E_COMPILE_ERROR,
+						"Variadic placeholder must be last");
+				}
+			}
+
+			if (arg->kind != ZEND_AST_PLACEHOLDER_ARG
+					|| arg->attr != _IS_PLACEHOLDER_VARIADIC) {
+				arg_count++;
+			}
+		}
+
+		if (arg->kind == ZEND_AST_PLACEHOLDER_ARG) {
+			if (uses_arg_unpack) {
+				zend_error_noreturn(E_COMPILE_ERROR,
+					"Cannot combine partial application and unpacking");
+			}
+
+			if (arg->attr == _IS_PLACEHOLDER_VARIADIC) {
+				uses_variadic_placeholder = true;
+			}
+
+			fbc = NULL;
+
+			opline = zend_emit_op(NULL, ZEND_SEND_PLACEHOLDER, NULL, NULL);
+			opline->op1.num = arg->attr;
+			if (arg_name) {
+				opline->op2_type = IS_CONST;
+				zend_string_addref(arg_name);
+				opline->op2.constant = zend_add_literal_string(&arg_name);
+				opline->result.num = zend_alloc_cache_slots(2);
+			} else if (arg->attr != _IS_PLACEHOLDER_VARIADIC) {
+				opline->op2.opline_num = arg_num;
+				opline->result.var = EX_NUM_TO_VAR(arg_num - 1);
+			}
+
+			continue;
 		}
 
 		/* Treat passing of $GLOBALS the same as passing a call.
@@ -3906,8 +3963,13 @@ static uint32_t zend_compile_args(
 		}
 	}
 
-	if (may_have_undef) {
-		zend_emit_op(NULL, ZEND_CHECK_UNDEF_ARGS, NULL, NULL);
+	if (!is_call_partial) {
+		if (may_have_undef) {
+			zend_emit_op(NULL, ZEND_CHECK_UNDEF_ARGS, NULL, NULL);
+		}
+	} else {
+		// TODO: merge this opcode with ZEND_CALLABLE_CONVERT_PARTIAL?
+		zend_emit_op(NULL, ZEND_CHECK_PARTIAL_ARGS, NULL, NULL);
 	}
 
 	return arg_count;
@@ -3947,10 +4009,35 @@ ZEND_API uint8_t zend_get_call_op(const zend_op *init_op, zend_function *fbc, bo
 }
 /* }}} */
 
-static bool zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function *fbc, uint32_t lineno) /* {{{ */
+void zend_compile_call_partial(znode *result, zend_ast *call_ast,
+		uint32_t arg_count, bool may_have_extra_named_args, uint32_t opnum_init,
+		zend_function *fbc) { /* {{{ */
+
+	zend_op *opline = &CG(active_op_array)->opcodes[opnum_init];
+
+	opline->extended_value = arg_count;
+
+	ZEND_ASSERT(opline->opcode != ZEND_NEW);
+
+	if (opline->opcode == ZEND_INIT_FCALL) {
+		opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc);
+	}
+
+	opline = zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT_PARTIAL,
+				NULL, NULL);
+
+	opline->op1.num = zend_alloc_cache_slots(2);
+
+	if (may_have_extra_named_args) {
+		opline->extended_value = ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS;
+	}
+}
+
+static bool zend_compile_call_common(znode *result, zend_ast *call_ast, zend_ast *args_ast, zend_function *fbc, uint32_t lineno) /* {{{ */
 {
 	zend_op *opline;
 	uint32_t opnum_init = get_next_op_number() - 1;
+	bool may_have_extra_named_args;
 
 	if (args_ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		opline = &CG(active_op_array)->opcodes[opnum_init];
@@ -3960,16 +4047,31 @@ static bool zend_compile_call_common(znode *result, zend_ast *args_ast, zend_fun
 		    zend_error_noreturn(E_COMPILE_ERROR, "Cannot create Closure for new expression");
 		}
 
-		if (opline->opcode == ZEND_INIT_FCALL) {
-			opline->op1.num = zend_vm_calc_used_stack(0, fbc);
+		zend_ast_list *fcc_args = zend_ast_get_list(((zend_ast_fcc*)args_ast)->args);
+
+		/* FCCs are a special case of PFAs with a single variadic placeholder */
+		if (fcc_args->children == 1 && fcc_args->child[0]->attr == _IS_PLACEHOLDER_VARIADIC) {
+
+			if (opline->opcode == ZEND_INIT_FCALL) {
+				opline->op1.num = zend_vm_calc_used_stack(0, fbc);
+			}
+
+			zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT, NULL, NULL);
+
+			return true;
 		}
 
-		zend_emit_op_tmp(result, ZEND_CALLABLE_CONVERT, NULL, NULL);
+		args_ast = ((zend_ast_fcc*)args_ast)->args;
+		uint32_t arg_count = zend_compile_args(args_ast, fbc, true,
+				&may_have_extra_named_args);
+
+		zend_compile_call_partial(result, call_ast, arg_count,
+				may_have_extra_named_args, opnum_init, fbc);
 		return true;
 	}
 
-	bool may_have_extra_named_args;
-	uint32_t arg_count = zend_compile_args(args_ast, fbc, &may_have_extra_named_args);
+	uint32_t arg_count = zend_compile_args(args_ast, fbc,
+			false, &may_have_extra_named_args);
 
 	zend_do_extended_fcall_begin();
 
@@ -4012,7 +4114,7 @@ static bool zend_compile_function_name(znode *name_node, zend_ast *name_ast) /*
 }
 /* }}} */
 
-static void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *args_ast, uint32_t lineno) /* {{{ */
+static void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast *call_ast, zend_ast *args_ast, uint32_t lineno) /* {{{ */
 {
 	if (name_node->op_type == IS_CONST && Z_TYPE(name_node->u.constant) == IS_STRING) {
 		const char *colon;
@@ -4042,7 +4144,7 @@ static void zend_compile_dynamic_call(znode *result, znode *name_node, zend_ast
 		zend_emit_op(NULL, ZEND_INIT_DYNAMIC_CALL, NULL, name_node);
 	}
 
-	zend_compile_call_common(result, args_ast, NULL, lineno);
+	zend_compile_call_common(result, call_ast, args_ast, NULL, lineno);
 }
 /* }}} */
 
@@ -4051,7 +4153,8 @@ static inline bool zend_args_contain_unpack_or_named(zend_ast_list *args) /* {{{
 	uint32_t i;
 	for (i = 0; i < args->children; ++i) {
 		zend_ast *arg = args->child[i];
-		if (arg->kind == ZEND_AST_UNPACK || arg->kind == ZEND_AST_NAMED_ARG) {
+		if (arg->kind == ZEND_AST_UNPACK ||
+			arg->kind == ZEND_AST_NAMED_ARG) {
 			return 1;
 		}
 	}
@@ -4394,7 +4497,7 @@ static void zend_compile_assert(znode *result, zend_ast_list *args, zend_string
 			args = (zend_ast_list *)zend_ast_list_add((zend_ast *) args, arg);
 		}
 
-		zend_compile_call_common(result, (zend_ast*)args, fbc, lineno);
+		zend_compile_call_common(result, NULL, (zend_ast*)args, fbc, lineno);
 
 		opline = &CG(active_op_array)->opcodes[check_op_number];
 		opline->op2.opline_num = get_next_op_number();
@@ -4724,7 +4827,7 @@ static uint32_t zend_compile_frameless_icall(znode *result, zend_ast_list *args,
 	return zend_compile_frameless_icall_ex(result, args, fbc, frameless_function_info, type);
 }
 
-static void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args_ast, uint32_t lineno, uint32_t type) /* {{{ */
+static void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *call_ast, zend_ast *args_ast, uint32_t lineno, uint32_t type) /* {{{ */
 {
 	int name_constants = zend_add_ns_func_name_literal(Z_STR(name_node->u.constant));
 
@@ -4759,7 +4862,7 @@ static void zend_compile_ns_call(znode *result, znode *name_node, zend_ast *args
 	opline->op2_type = IS_CONST;
 	opline->op2.constant = name_constants;
 	opline->result.num = zend_alloc_cache_slot();
-	zend_compile_call_common(result, args_ast, NULL, lineno);
+	zend_compile_call_common(result, call_ast, args_ast, NULL, lineno);
 
 	/* Compile frameless call. */
 	if (frameless_function_info) {
@@ -5146,7 +5249,7 @@ static bool zend_compile_parent_property_hook_call(znode *result, zend_ast *ast,
 	opline->op2.num = hook_kind;
 
 	zend_function *fbc = NULL;
-	zend_compile_call_common(result, args_ast, fbc, zend_ast_get_lineno(method_ast));
+	zend_compile_call_common(result, ast, args_ast, fbc, zend_ast_get_lineno(method_ast));
 
 	return true;
 }
@@ -5161,7 +5264,7 @@ static void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{
 
 	if (name_ast->kind != ZEND_AST_ZVAL || Z_TYPE_P(zend_ast_get_zval(name_ast)) != IS_STRING) {
 		zend_compile_expr(&name_node, name_ast);
-		zend_compile_dynamic_call(result, &name_node, args_ast, ast->lineno);
+		zend_compile_dynamic_call(result, &name_node, ast, args_ast, ast->lineno);
 		return;
 	}
 
@@ -5172,7 +5275,7 @@ static void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{
 					&& !is_callable_convert) {
 				zend_compile_assert(result, zend_ast_get_list(args_ast), Z_STR(name_node.u.constant), NULL, ast->lineno);
 			} else {
-				zend_compile_ns_call(result, &name_node, args_ast, ast->lineno, type);
+				zend_compile_ns_call(result, &name_node, ast, args_ast, ast->lineno, type);
 			}
 			return;
 		}
@@ -5200,7 +5303,7 @@ static void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{
 		 || !fbc_is_finalized(fbc)
 		 || zend_compile_ignore_function(fbc, CG(active_op_array)->filename)) {
 			zend_string_release_ex(lcname, 0);
-			zend_compile_dynamic_call(result, &name_node, args_ast, ast->lineno);
+			zend_compile_dynamic_call(result, &name_node, ast, args_ast, ast->lineno);
 			return;
 		}
 
@@ -5225,7 +5328,7 @@ static void zend_compile_call(znode *result, zend_ast *ast, uint32_t type) /* {{
 			Z_EXTRA_P(CT_CONSTANT(opline->op2)) = fbc_bucket - CG(function_table)->arData;
 		}
 
-		zend_compile_call_common(result, args_ast, fbc, ast->lineno);
+		zend_compile_call_common(result, ast, args_ast, fbc, ast->lineno);
 	}
 }
 /* }}} */
@@ -5289,7 +5392,7 @@ static void zend_compile_method_call(znode *result, zend_ast *ast, uint32_t type
 		}
 	}
 
-	if (zend_compile_call_common(result, args_ast, fbc, zend_ast_get_lineno(method_ast))) {
+	if (zend_compile_call_common(result, ast, args_ast, fbc, zend_ast_get_lineno(method_ast))) {
 		if (short_circuiting_checkpoint != zend_short_circuiting_checkpoint()) {
 			zend_error_noreturn(E_COMPILE_ERROR,
 				"Cannot combine nullsafe operator with Closure creation");
@@ -5394,7 +5497,7 @@ static void zend_compile_static_call(znode *result, zend_ast *ast, uint32_t type
 		}
 	}
 
-	zend_compile_call_common(result, args_ast, fbc, zend_ast_get_lineno(method_ast));
+	zend_compile_call_common(result, ast, args_ast, fbc, zend_ast_get_lineno(method_ast));
 }
 /* }}} */
 
@@ -5426,7 +5529,7 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
 		SET_NODE(opline->op1, &class_node);
 	}
 
-	zend_compile_call_common(&ctor_result, args_ast, NULL, ast->lineno);
+	zend_compile_call_common(&ctor_result, ast, args_ast, NULL, ast->lineno);
 	zend_do_free(&ctor_result);
 }
 /* }}} */
@@ -6481,6 +6584,76 @@ static bool zend_is_pipe_optimizable_callable_name(zend_ast *ast)
 	return true;
 }
 
+static zend_ast *zend_partial_apply(zend_ast *callable_ast, zend_ast *pipe_arg)
+{
+	if (callable_ast->kind != ZEND_AST_CALL
+			&& callable_ast->kind != ZEND_AST_STATIC_CALL
+			&& callable_ast->kind != ZEND_AST_METHOD_CALL) {
+		return NULL;
+	}
+
+	zend_ast *args_ast = zend_ast_call_get_args(callable_ast);
+	if (!args_ast || args_ast->kind != ZEND_AST_CALLABLE_CONVERT) {
+		return NULL;
+	}
+
+	if (callable_ast->kind == ZEND_AST_CALL &&
+			!zend_is_pipe_optimizable_callable_name(callable_ast->child[0])) {
+		return NULL;
+	}
+
+	zend_ast_list *arg_list = zend_ast_get_list(((zend_ast_fcc*)args_ast)->args);
+
+	zend_ast *first_placeholder = NULL;
+	bool uses_named_args = false;
+
+	for (uint32_t i = 0; i < arg_list->children; i++) {
+		zend_ast *arg = arg_list->child[i];
+		if (arg->kind == ZEND_AST_NAMED_ARG) {
+			uses_named_args = true;
+			arg = arg->child[1];
+		}
+
+		if (arg->kind == ZEND_AST_PLACEHOLDER_ARG) {
+			if (first_placeholder == NULL) {
+				first_placeholder = arg;
+			} else {
+				/* A PFA with multiple placeholders is unexpected is this
+				 * context, and will usually error due to a missing argument,
+				 * so we don't optimize those. */
+				return NULL;
+			}
+			if (arg->attr == _IS_PLACEHOLDER_VARIADIC && uses_named_args) {
+				/* PFAs with both a variadic placeholder and named args can not
+				 * be optimized because the named arg may resolve to the
+				 * position of the placeholder: f(..., name: $v).
+				 * Arg placeholders ('?') are safe, as named args are not
+				 * allowed to override them. */
+				return NULL;
+			}
+		}
+	}
+
+	ZEND_ASSERT(first_placeholder);
+
+	zend_ast *new_arg_list = zend_ast_create_list(0, arg_list->kind);
+	for (uint32_t i = 0; i < arg_list->children; i++) {
+		zend_ast *arg = arg_list->child[i];
+		if (arg == first_placeholder) {
+			new_arg_list = zend_ast_list_add(new_arg_list, pipe_arg);
+		} else if (arg->kind == ZEND_AST_NAMED_ARG
+				&& arg->child[1] == first_placeholder) {
+			zend_ast *name = arg->child[0];
+			new_arg_list = zend_ast_list_add(new_arg_list,
+					zend_ast_create(ZEND_AST_NAMED_ARG, name, pipe_arg));
+		} else {
+			new_arg_list = zend_ast_list_add(new_arg_list, arg);
+		}
+	}
+
+	return new_arg_list;
+}
+
 static void zend_compile_pipe(znode *result, zend_ast *ast)
 {
 	zend_ast *operand_ast = ast->child[0];
@@ -6505,29 +6678,34 @@ static void zend_compile_pipe(znode *result, zend_ast *ast)
 	}
 
 	/* Turn the operand into a function parameter list. */
-	zend_ast *arg_list_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, zend_ast_create_znode(&wrapped_operand_result));
+	zend_ast *arg = zend_ast_create_znode(&wrapped_operand_result);
 
 	zend_ast *fcall_ast;
 	znode callable_result;
+	zend_ast *pfa_arg_list_ast = NULL;
 
-	/* Turn $foo |> bar(...) into bar($foo). */
-	if (callable_ast->kind == ZEND_AST_CALL
-		&& callable_ast->child[1]->kind == ZEND_AST_CALLABLE_CONVERT
-		&& zend_is_pipe_optimizable_callable_name(callable_ast->child[0])) {
-		fcall_ast = zend_ast_create(ZEND_AST_CALL,
-				callable_ast->child[0], arg_list_ast);
-	/* Turn $foo |> bar::baz(...) into bar::baz($foo). */
-	} else if (callable_ast->kind == ZEND_AST_STATIC_CALL
-			&& callable_ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT) {
-		fcall_ast = zend_ast_create(ZEND_AST_STATIC_CALL,
-			callable_ast->child[0], callable_ast->child[1], arg_list_ast);
-	/* Turn $foo |> $bar->baz(...) into $bar->baz($foo). */
-	} else if (callable_ast->kind == ZEND_AST_METHOD_CALL
-			&& callable_ast->child[2]->kind == ZEND_AST_CALLABLE_CONVERT) {
-		fcall_ast = zend_ast_create(ZEND_AST_METHOD_CALL,
-			callable_ast->child[0], callable_ast->child[1], arg_list_ast);
+	/* Turn $foo |> PFA into plain function call if possible */
+	if ((pfa_arg_list_ast = zend_partial_apply(callable_ast, arg))) {
+		switch (callable_ast->kind) {
+			case ZEND_AST_CALL:
+				fcall_ast = zend_ast_create(ZEND_AST_CALL,
+						callable_ast->child[0], pfa_arg_list_ast);
+				break;
+			case ZEND_AST_STATIC_CALL:
+				fcall_ast = zend_ast_create(ZEND_AST_STATIC_CALL,
+						callable_ast->child[0], callable_ast->child[1],
+						pfa_arg_list_ast);
+				break;
+			case ZEND_AST_METHOD_CALL:
+				fcall_ast = zend_ast_create(ZEND_AST_METHOD_CALL,
+						callable_ast->child[0], callable_ast->child[1],
+						pfa_arg_list_ast);
+				break;
+			EMPTY_SWITCH_DEFAULT_CASE()
+		}
 	/* Turn $foo |> $expr into ($expr)($foo) */
 	} else {
+		zend_ast *arg_list_ast = zend_ast_create_list(1, ZEND_AST_ARG_LIST, arg);
 		zend_compile_expr(&callable_result, callable_ast);
 		callable_ast = zend_ast_create_znode(&callable_result);
 		fcall_ast = zend_ast_create(ZEND_AST_CALL,
@@ -11517,6 +11695,13 @@ static void zend_compile_const_expr_fcc(zend_ast **ast_ptr)
 	if ((*args_ast)->kind != ZEND_AST_CALLABLE_CONVERT) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
 	}
+
+	zend_ast_list *args = zend_ast_get_list(((zend_ast_fcc*)*args_ast)->args);
+	if (args->children != 1 || args->child[0]->attr != _IS_PLACEHOLDER_VARIADIC) {
+		// TODO: PFAs
+		zend_error_noreturn(E_COMPILE_ERROR, "Constant expression contains invalid operations");
+	}
+
 	ZEND_MAP_PTR_NEW(((zend_ast_fcc *)*args_ast)->fptr);
 
 	switch ((*ast_ptr)->kind) {
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index c07fa9bfa7d7e..e4a3c0058f4b8 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -938,6 +938,7 @@ struct _zend_arena;
 ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type);
 ZEND_API zend_op_array *compile_string(zend_string *source_string, const char *filename, zend_compile_position position);
 ZEND_API zend_op_array *compile_filename(int type, zend_string *filename);
+ZEND_API zend_op_array *zend_compile_ast(zend_ast *ast, int type, zend_string *filename);
 ZEND_API zend_ast *zend_compile_string_to_ast(
 		zend_string *code, struct _zend_arena **ast_arena, zend_string *filename);
 ZEND_API zend_result zend_execute_scripts(int type, zval *retval, int file_count, ...);
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index ba9a7fa7e528f..304a17e351126 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -45,6 +45,7 @@
 #include "zend_call_stack.h"
 #include "zend_attributes.h"
 #include "Optimizer/zend_func_info.h"
+#include "zend_partial.h"
 
 /* Virtual current working directory support */
 #include "zend_virtual_cwd.h"
@@ -1231,6 +1232,13 @@ static zend_always_inline bool zend_check_type(
 	return zend_check_type_slow(type, arg, ref, is_return_type, is_internal);
 }
 
+ZEND_API bool zend_check_type_ex(
+		const zend_type *type, zval *arg, zend_class_entry *scope,
+		bool is_return_type, bool is_internal)
+{
+	return zend_check_type(type, arg, scope, is_return_type, is_internal);
+}
+
 ZEND_API bool zend_check_user_type_slow(
 		const zend_type *type, zval *arg, const zend_reference *ref, bool is_return_type)
 {
@@ -4758,6 +4766,7 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o
 					case ZEND_DO_UCALL:
 					case ZEND_DO_FCALL_BY_NAME:
 					case ZEND_CALLABLE_CONVERT:
+					case ZEND_CALLABLE_CONVERT_PARTIAL:
 						level++;
 						break;
 					case ZEND_INIT_FCALL:
@@ -4795,6 +4804,7 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o
 					case ZEND_SEND_ARRAY:
 					case ZEND_SEND_UNPACK:
 					case ZEND_CHECK_UNDEF_ARGS:
+					case ZEND_CHECK_PARTIAL_ARGS:
 						if (level == 0) {
 							do_exit = 1;
 						}
@@ -4815,6 +4825,7 @@ static void cleanup_unfinished_calls(zend_execute_data *execute_data, uint32_t o
 						case ZEND_DO_UCALL:
 						case ZEND_DO_FCALL_BY_NAME:
 						case ZEND_CALLABLE_CONVERT:
+						case ZEND_CALLABLE_CONVERT_PARTIAL:
 							level++;
 							break;
 						case ZEND_INIT_FCALL:
@@ -5529,9 +5540,10 @@ zval * ZEND_FASTCALL zend_handle_named_arg(
 		}
 	} else {
 		arg = ZEND_CALL_VAR_NUM(call, arg_offset);
+
 		if (UNEXPECTED(!Z_ISUNDEF_P(arg))) {
-			zend_throw_error(NULL, "Named parameter $%s overwrites previous argument",
-				ZSTR_VAL(arg_name));
+			zend_throw_error(NULL, "Named parameter $%s overwrites previous %s",
+				ZSTR_VAL(arg_name), Z_TYPE_P(arg) == _IS_PLACEHOLDER_ARG ? "placeholder" : "argument");
 			return NULL;
 		}
 	}
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 13fb1ab7667a3..52aa423a4594e 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -110,6 +110,9 @@ ZEND_API ZEND_COLD void zend_verify_never_error(
 ZEND_API bool zend_verify_ref_array_assignable(zend_reference *ref);
 ZEND_API bool zend_check_user_type_slow(
 		const zend_type *type, zval *arg, const zend_reference *ref, bool is_return_type);
+ZEND_API bool zend_check_type_ex(
+		const zend_type *type, zval *arg, zend_class_entry *scope,
+		bool is_return_type, bool is_internal);
 
 #if ZEND_DEBUG
 ZEND_API bool zend_internal_call_should_throw(const zend_function *fbc, zend_execute_data *call);
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index e4d61006fe12f..faa63144bc651 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -901,16 +901,15 @@ return_type:
 ;
 
 argument_list:
-		'(' ')'	{ $$ = zend_ast_create_list(0, ZEND_AST_ARG_LIST); }
+		'(' ')'	{ $$ = zend_ast_create_arg_list(0, ZEND_AST_ARG_LIST); }
 	|	'(' non_empty_argument_list possible_comma ')' { $$ = $2; }
-	|	'(' T_ELLIPSIS ')' { $$ = zend_ast_create_fcc(); }
 ;
 
 non_empty_argument_list:
 		argument
-			{ $$ = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $1); }
+			{ $$ = zend_ast_create_arg_list(1, ZEND_AST_ARG_LIST, $1); }
 	|	non_empty_argument_list ',' argument
-			{ $$ = zend_ast_list_add($1, $3); }
+			{ $$ = zend_ast_arg_list_add($1, $3); }
 ;
 
 /* `clone_argument_list` is necessary to resolve a parser ambiguity (shift-reduce conflict)
@@ -923,25 +922,31 @@ non_empty_argument_list:
  * syntax.
  */
 clone_argument_list:
-		'(' ')'	{ $$ = zend_ast_create_list(0, ZEND_AST_ARG_LIST); }
+		'(' ')'	{ $$ = zend_ast_create_arg_list(0, ZEND_AST_ARG_LIST); }
 	|	'(' non_empty_clone_argument_list possible_comma ')' { $$ = $2; }
-	|	'(' expr ',' ')' { $$ = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $2); }
-	|	'(' T_ELLIPSIS ')' { $$ = zend_ast_create_fcc(); }
+	|	'(' expr ',' ')' { $$ = zend_ast_create_arg_list(1, ZEND_AST_ARG_LIST, $2); }
 ;
 
 non_empty_clone_argument_list:
 		expr ',' argument
-			{ $$ = zend_ast_create_list(2, ZEND_AST_ARG_LIST, $1, $3); }
+			{ $$ = zend_ast_create_arg_list(2, ZEND_AST_ARG_LIST, $1, $3); }
 	|	argument_no_expr
-			{ $$ = zend_ast_create_list(1, ZEND_AST_ARG_LIST, $1); }
+			{ $$ = zend_ast_create_arg_list(1, ZEND_AST_ARG_LIST, $1); }
 	|	non_empty_clone_argument_list ',' argument
-			{ $$ = zend_ast_list_add($1, $3); }
+			{ $$ = zend_ast_arg_list_add($1, $3); }
 ;
 
 argument_no_expr:
 		identifier ':' expr
 			{ $$ = zend_ast_create(ZEND_AST_NAMED_ARG, $1, $3); }
-	|	T_ELLIPSIS expr	{ $$ = zend_ast_create(ZEND_AST_UNPACK, $2); }
+	|	T_ELLIPSIS
+			{ $$ = zend_ast_create_ex(ZEND_AST_PLACEHOLDER_ARG, _IS_PLACEHOLDER_VARIADIC); }
+	|	'?'
+			{ $$ = zend_ast_create_ex(ZEND_AST_PLACEHOLDER_ARG, _IS_PLACEHOLDER_ARG); }
+	|	identifier ':' '?'
+			{ $$ = zend_ast_create(ZEND_AST_NAMED_ARG, $1, zend_ast_create_ex(ZEND_AST_PLACEHOLDER_ARG, _IS_PLACEHOLDER_ARG)); }
+	|	T_ELLIPSIS expr
+			{ $$ = zend_ast_create(ZEND_AST_UNPACK, $2); }
 ;
 
 argument:
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 3ecb2f8d0ee45..236fffb36cd33 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -590,6 +590,43 @@ ZEND_API zend_result open_file_for_scanning(zend_file_handle *file_handle)
 	return SUCCESS;
 }
 
+static zend_op_array *zend_compile_ast_internal(int type)
+{
+	ZEND_ASSERT(CG(in_compilation));
+	ZEND_ASSERT(CG(ast));
+
+	int last_lineno = CG(zend_lineno);
+	zend_file_context original_file_context;
+	zend_oparray_context original_oparray_context;
+	zend_op_array *original_active_op_array = CG(active_op_array);
+
+	zend_op_array *op_array = emalloc(sizeof(zend_op_array));
+	init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);
+	CG(active_op_array) = op_array;
+
+	/* Use heap to not waste arena memory */
+	op_array->fn_flags |= ZEND_ACC_HEAP_RT_CACHE;
+
+	if (zend_ast_process) {
+		zend_ast_process(CG(ast));
+	}
+
+	zend_file_context_begin(&original_file_context);
+	zend_oparray_context_begin(&original_oparray_context, op_array);
+	zend_compile_top_stmt(CG(ast));
+	CG(zend_lineno) = last_lineno;
+	zend_emit_final_return(type == ZEND_USER_FUNCTION);
+	op_array->line_start = 1;
+	op_array->line_end = last_lineno;
+	pass_two(op_array);
+	zend_oparray_context_end(&original_oparray_context);
+	zend_file_context_end(&original_file_context);
+
+	CG(active_op_array) = original_active_op_array;
+
+	return op_array;
+}
+
 static zend_op_array *zend_compile(int type)
 {
 	zend_op_array *op_array = NULL;
@@ -600,34 +637,7 @@ static zend_op_array *zend_compile(int type)
 	CG(ast_arena) = zend_arena_create(1024 * 32);
 
 	if (!zendparse()) {
-		int last_lineno = CG(zend_lineno);
-		zend_file_context original_file_context;
-		zend_oparray_context original_oparray_context;
-		zend_op_array *original_active_op_array = CG(active_op_array);
-
-		op_array = emalloc(sizeof(zend_op_array));
-		init_op_array(op_array, type, INITIAL_OP_ARRAY_SIZE);
-		CG(active_op_array) = op_array;
-
-		/* Use heap to not waste arena memory */
-		op_array->fn_flags |= ZEND_ACC_HEAP_RT_CACHE;
-
-		if (zend_ast_process) {
-			zend_ast_process(CG(ast));
-		}
-
-		zend_file_context_begin(&original_file_context);
-		zend_oparray_context_begin(&original_oparray_context, op_array);
-		zend_compile_top_stmt(CG(ast));
-		CG(zend_lineno) = last_lineno;
-		zend_emit_final_return(type == ZEND_USER_FUNCTION);
-		op_array->line_start = 1;
-		op_array->line_end = last_lineno;
-		pass_two(op_array);
-		zend_oparray_context_end(&original_oparray_context);
-		zend_file_context_end(&original_file_context);
-
-		CG(active_op_array) = original_active_op_array;
+		op_array = zend_compile_ast_internal(type);
 	}
 
 	zend_ast_destroy(CG(ast));
@@ -670,6 +680,23 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type)
 	return op_array;
 }
 
+ZEND_API zend_op_array *zend_compile_ast(
+	zend_ast *ast, int type, zend_string *filename)
+{
+	zend_string *original_compiled_filename = CG(compiled_filename);
+	bool original_in_compilation = CG(in_compilation);
+	CG(in_compilation) = 1;
+	CG(ast) = ast;
+
+	zend_set_compiled_filename(filename);
+	zend_op_array *op_array = zend_compile_ast_internal(type);
+
+	CG(in_compilation) = original_in_compilation;
+	zend_restore_compiled_filename(original_compiled_filename);
+
+	return op_array;
+}
+
 ZEND_API zend_ast *zend_compile_string_to_ast(
 		zend_string *code, zend_arena **ast_arena, zend_string *filename) {
 	zval code_zv;
diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index cca69e5d792c9..f4e70578c821d 100644
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -39,6 +39,8 @@
 #define ZEND_WRONG_PROPERTY_OFFSET   0
 #define ZEND_HOOKED_PROPERTY_OFFSET 1
 
+static zend_arg_info zend_call_trampoline_arginfo[1] = {{0}};
+
 /* guard flags */
 #define IN_GET		ZEND_GUARD_PROPERTY_GET
 #define IN_SET		ZEND_GUARD_PROPERTY_SET
@@ -1669,6 +1671,13 @@ ZEND_API bool zend_check_protected(const zend_class_entry *ce, const zend_class_
 }
 /* }}} */
 
+static zend_always_inline zend_arg_info* zend_get_call_trampoline_arginfo(void) {
+	if (UNEXPECTED(zend_call_trampoline_arginfo[0].name == NULL)) {
+		zend_call_trampoline_arginfo[0].name = ZSTR_KNOWN(ZEND_STR_ARGS);
+	}
+	return zend_call_trampoline_arginfo;
+}
+
 ZEND_API zend_function *zend_get_call_trampoline_func(const zend_class_entry *ce, zend_string *method_name, bool is_static) /* {{{ */
 {
 	size_t mname_len;
@@ -1678,7 +1687,6 @@ ZEND_API zend_function *zend_get_call_trampoline_func(const zend_class_entry *ce
 	 * The low bit must be zero, to not be interpreted as a MAP_PTR offset.
 	 */
 	static const void *dummy = (void*)(intptr_t)2;
-	static const zend_arg_info arg_info[1] = {{0}};
 
 	ZEND_ASSERT(fbc);
 
@@ -1729,7 +1737,7 @@ ZEND_API zend_function *zend_get_call_trampoline_func(const zend_class_entry *ce
 	func->prop_info = NULL;
 	func->num_args = 0;
 	func->required_num_args = 0;
-	func->arg_info = (zend_arg_info *) arg_info;
+	func->arg_info = zend_get_call_trampoline_arginfo();
 
 	return (zend_function*)func;
 }
diff --git a/Zend/zend_partial.c b/Zend/zend_partial.c
new file mode 100644
index 0000000000000..a4a2ad581859d
--- /dev/null
+++ b/Zend/zend_partial.c
@@ -0,0 +1,960 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+*/
+
+#include "zend.h"
+#include "zend_API.h"
+#include "zend_arena.h"
+#include "zend_ast.h"
+#include "zend_compile.h"
+#include "zend_closures.h"
+#include "zend_attributes.h"
+#include "zend_exceptions.h"
+#include "ext/opcache/ZendAccelerator.h"
+
+#define Z_IS_PLACEHOLDER_ARG_P(p) \
+	(Z_TYPE_P(p) == _IS_PLACEHOLDER_ARG)
+
+#define Z_IS_PLACEHOLDER_VARIADIC_P(p) \
+	(Z_TYPE_P(p) == _IS_PLACEHOLDER_VARIADIC)
+
+#define Z_IS_PLACEHOLDER_P(p) \
+	(Z_IS_PLACEHOLDER_ARG_P(p) || Z_IS_PLACEHOLDER_VARIADIC_P(p))
+
+#define IS_STATIC_CLOSURE(function) \
+	(((function)->common.fn_flags & (ZEND_ACC_STATIC|ZEND_ACC_CLOSURE)) == (ZEND_ACC_STATIC|ZEND_ACC_CLOSURE))
+
+static zend_string* zend_partial_symbol_name(zend_execute_data *call, zend_function *function) {
+	zend_string *name = function->common.function_name,
+				*scope = (function->common.scope ? function->common.scope->name : NULL),
+				*symbol;
+
+	if (scope) {
+		symbol = zend_create_member_string(scope, name);
+	} else {
+		symbol = zend_string_copy(name);
+	}
+
+	return symbol;
+}
+
+static zend_always_inline void zend_partial_args_underflow(
+		zend_function *function, zend_string *symbol, uint32_t args,
+		uint32_t expected)
+{
+	const char *limit = function->common.num_args <= function->common.required_num_args ?
+			"exactly" : "at least";
+
+	zend_throw_error(NULL,
+		"not enough arguments or placeholders for application of %s, "
+		"%d given and %s %d expected",
+		ZSTR_VAL(symbol), args, limit, expected);
+}
+
+static zend_always_inline void zend_partial_args_overflow(
+		zend_function *function, zend_string *symbol, uint32_t args,
+		uint32_t expected)
+{
+	if (function->type == ZEND_USER_FUNCTION) {
+		zend_throw_error(NULL,
+			"too many arguments or placeholders for application of %s, "
+			"%d given and a maximum of %d expected",
+			ZSTR_VAL(symbol), args, expected);
+	} else {
+		zend_throw_error(NULL,
+			"too many arguments or placeholders for application of %s, "
+			"%d given and a maximum of %d expected",
+			ZSTR_VAL(symbol), args, expected);
+	}
+}
+
+void zend_partial_args_check(zend_execute_data *call) {
+	/* this is invoked by VM before the creation of partial */
+	// TODO: merge with zend_partial_create()?
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
+		zend_array *named_args = call->extra_named_params;
+		zval *arg;
+		zend_string *key;
+		ZEND_HASH_MAP_FOREACH_STR_KEY_VAL(named_args, key, arg) {
+			if (UNEXPECTED(Z_TYPE_P(arg) == _IS_PLACEHOLDER_ARG)) {
+				zend_throw_error(NULL,
+						"Cannot use named placeholder for unknown or variadic parameter $%s",
+						ZSTR_VAL(key));
+				return;
+			}
+		} ZEND_HASH_FOREACH_END();
+	}
+
+	zend_function *function = call->func;
+
+	/* Z_EXTRA(ZEND_CALL_ARG(call, 1)) is set by ZEND_SEND_PLACEHOLDER */
+	bool variadic = Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) == _IS_PLACEHOLDER_VARIADIC;
+
+	uint32_t num = ZEND_CALL_NUM_ARGS(call) + (variadic ? -1 : 0);
+
+	if (num < function->common.required_num_args) {
+		if (variadic) {
+			return;
+		}
+
+		zend_string *symbol = zend_partial_symbol_name(call, function);
+		zend_partial_args_underflow(
+			function, symbol,
+			num, function->common.required_num_args);
+		zend_string_release(symbol);
+	} else if (num > function->common.num_args &&
+			!(function->common.fn_flags & ZEND_ACC_VARIADIC)) {
+		zend_string *symbol = zend_partial_symbol_name(call, function);
+		zend_partial_args_overflow(
+			function, symbol,
+			num, function->common.num_args);
+		zend_string_release(symbol);
+	}
+}
+
+static bool zp_name_exists(zend_string **names, uint32_t num_names, zend_string *name)
+{
+	for (uint32_t i = 0; i < num_names; i++) {
+		if (names[i] && zend_string_equals(names[i], name)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+static zend_string *zp_get_param_name(zend_function *function, uint32_t arg_offset)
+{
+	zend_arg_info *arg_info = &function->common.arg_info[arg_offset];
+
+	if (function->type == ZEND_USER_FUNCTION
+			|| (function->common.fn_flags & ZEND_ACC_USER_ARG_INFO)) {
+		return zend_string_copy(arg_info->name);
+	} else {
+		const char *name = ((zend_internal_arg_info*)arg_info)->name;
+		return zend_string_init(name, strlen(name), false);
+	}
+}
+
+static void zp_assign_names(zend_string **names, uint32_t num_names,
+		uint32_t argc, zval *argv,
+		zend_function *function, bool variadic_partial,
+		zend_array *extra_named_params)
+{
+	/* Assign names for normal params. We never rename those. */
+	for (uint32_t offset = 0; offset < MIN(argc, function->common.num_args); offset++) {
+		if (Z_IS_PLACEHOLDER_P(&argv[offset])) {
+			names[offset] = zp_get_param_name(function, offset);
+		}
+	}
+
+	/* Assign names for the variadic param. Never renamed. */
+	if (variadic_partial && (function->common.fn_flags & ZEND_ACC_VARIADIC)) {
+		names[argc] = zp_get_param_name(function, function->common.num_args);
+	}
+
+	/* Assign names for placeholders that run into variadic.
+	 * By default these are named $origNameN with N the offset from the
+	 * variadic param. In case of clash we increment N until a free name is
+	 * found. */
+	for (uint32_t offset = function->common.num_args; offset < argc; offset++) {
+		ZEND_ASSERT(function->common.fn_flags & ZEND_ACC_VARIADIC);
+		if (!Z_IS_PLACEHOLDER_P(&argv[offset])) {
+			continue;
+		}
+		int n = offset - function->common.num_args;
+		zend_string *orig_name = zp_get_param_name(function, function->common.num_args);
+		zend_string *new_name;
+		do {
+			new_name = zend_strpprintf_unchecked(0, "%S%d", orig_name, n);
+			if (!zp_name_exists(names, num_names, new_name)) {
+				break;
+			}
+			n++;
+			zend_string_release(new_name);
+		} while (true);
+		names[offset] = new_name;
+		zend_string_release(orig_name);
+	}
+
+	/* Assign names for pre-bound params (lexical vars).
+	 * There may be clashes, we ensure to generate unique names. */
+	for (uint32_t offset = 0; offset < argc; offset++) {
+		if (Z_IS_PLACEHOLDER_P(&argv[offset]) || Z_ISUNDEF(argv[offset])) {
+			continue;
+		}
+		int n = -1;
+		zend_string *orig_name = zp_get_param_name(function, MIN(offset, function->common.num_args));
+		zend_string *new_name = zend_string_copy(orig_name);
+		while (zp_name_exists(names, num_names, new_name)) {
+			zend_string_release(new_name);
+			n++;
+			new_name = zend_strpprintf_unchecked(0, "%S%d", orig_name, n);
+		}
+		names[offset] = new_name;
+		zend_string_release(orig_name);
+	}
+
+	/* Assign name for $extra_named_params */
+	if (extra_named_params) {
+		int n = 1;
+		zend_string *new_name = ZSTR_INIT_LITERAL("extra_named_params", 0);
+		while (zp_name_exists(names, num_names, new_name)) {
+			zend_string_release(new_name);
+			n++;
+			new_name = zend_strpprintf(0, "%s%d", "extra_named_params", n);
+		}
+		names[argc + variadic_partial] = new_name;
+	}
+
+	/* Assign name for $fn */
+	if (function->common.fn_flags & ZEND_ACC_CLOSURE) {
+		int n = 1;
+		zend_string *new_name = ZSTR_INIT_LITERAL("fn", 0);
+		while (zp_name_exists(names, num_names, new_name)) {
+			zend_string_release(new_name);
+			n++;
+			new_name = zend_strpprintf(0, "%s%d", "fn", n);
+		}
+		names[argc + variadic_partial + (extra_named_params != NULL)] = new_name;
+	}
+}
+
+static bool zp_is_single_may_be_type(uint32_t type_mask)
+{
+	return ((type_mask > 0) && (type_mask & (type_mask - 1)) == 0)
+		|| type_mask == MAY_BE_BOOL
+		|| type_mask == MAY_BE_ANY;
+}
+
+static zend_ast *zp_single_may_be_type_to_ast(uint32_t type)
+{
+	zend_string *name;
+
+	switch (type) {
+		case MAY_BE_NULL:
+			name = ZSTR_KNOWN(ZEND_STR_NULL_LOWERCASE);
+			break;
+		case MAY_BE_TRUE:
+			name = ZSTR_KNOWN(ZEND_STR_TRUE);
+			break;
+		case MAY_BE_FALSE:
+			name = ZSTR_KNOWN(ZEND_STR_FALSE);
+			break;
+		case MAY_BE_LONG:
+			name = ZSTR_KNOWN(ZEND_STR_INT);
+			break;
+		case MAY_BE_DOUBLE:
+			name = ZSTR_KNOWN(ZEND_STR_FLOAT);
+			break;
+		case MAY_BE_STRING:
+			name = ZSTR_KNOWN(ZEND_STR_STRING);
+			break;
+		case MAY_BE_BOOL:
+			name = ZSTR_KNOWN(ZEND_STR_BOOL);
+			break;
+		case MAY_BE_VOID:
+			name = ZSTR_KNOWN(ZEND_STR_VOID);
+			break;
+		case MAY_BE_NEVER:
+			name = ZSTR_KNOWN(ZEND_STR_NEVER);
+			break;
+		case MAY_BE_OBJECT:
+			name = ZSTR_KNOWN(ZEND_STR_OBJECT);
+			break;
+		case MAY_BE_ANY:
+			name = ZSTR_KNOWN(ZEND_STR_MIXED);
+			break;
+		case MAY_BE_CALLABLE:
+			return zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE);
+		case MAY_BE_ARRAY:
+			return zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY);
+		case MAY_BE_STATIC:
+			return zend_ast_create_ex(ZEND_AST_TYPE, IS_STATIC);
+		EMPTY_SWITCH_DEFAULT_CASE()
+	}
+
+	zend_ast *ast = zend_ast_create_zval_from_str(name);
+	ast->attr = ZEND_NAME_NOT_FQ;
+
+	return ast;
+}
+
+static zend_ast *zp_type_name_to_ast(zend_string *name)
+{
+	zend_ast *ast = zend_ast_create_zval_from_str(name);
+
+	if (zend_get_class_fetch_type(name) != ZEND_FETCH_CLASS_DEFAULT) {
+		ast->attr = ZEND_NAME_NOT_FQ;
+	} else {
+		ast->attr = ZEND_NAME_FQ;
+	}
+
+	return ast;
+}
+
+static zend_ast *zp_type_to_ast(const zend_type type)
+{
+	if (!ZEND_TYPE_IS_SET(type)) {
+		return NULL;
+	}
+
+	if (ZEND_TYPE_IS_UNION(type)
+			|| (ZEND_TYPE_IS_COMPLEX(type) && ZEND_TYPE_PURE_MASK(type))
+			|| (ZEND_TYPE_PURE_MASK(type) && !zp_is_single_may_be_type(ZEND_TYPE_PURE_MASK(type)))) {
+		zend_ast *type_ast = zend_ast_create_list(0, ZEND_AST_TYPE_UNION);
+		if (ZEND_TYPE_HAS_LIST(type)) {
+			const zend_type *type_ptr;
+			ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), type_ptr) {
+				type_ast = zend_ast_list_add(type_ast, zp_type_to_ast(*type_ptr));
+			} ZEND_TYPE_LIST_FOREACH_END();
+		} else if (ZEND_TYPE_HAS_NAME(type)) {
+			zend_ast *name_ast = zp_type_name_to_ast(
+					zend_string_copy(ZEND_TYPE_NAME(type)));
+			type_ast = zend_ast_list_add(type_ast, name_ast);
+		} else if (ZEND_TYPE_IS_COMPLEX(type)) {
+			ZEND_UNREACHABLE();
+		}
+		uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
+		if ((type_mask & MAY_BE_BOOL) == MAY_BE_BOOL) {
+			type_ast = zend_ast_list_add(type_ast, zp_single_may_be_type_to_ast(MAY_BE_BOOL));
+			type_mask &= ~MAY_BE_BOOL;
+		}
+		for (uint32_t may_be_type = 1; may_be_type < _ZEND_TYPE_MAY_BE_MASK; may_be_type <<= 1) {
+			if (type_mask & may_be_type) {
+				type_ast = zend_ast_list_add(type_ast, zp_single_may_be_type_to_ast(may_be_type));
+			}
+		}
+		return type_ast;
+	}
+
+	if (ZEND_TYPE_IS_INTERSECTION(type)) {
+		zend_ast *type_ast = zend_ast_create_list(0, ZEND_AST_TYPE_INTERSECTION);
+		const zend_type *type_ptr;
+		ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(type), type_ptr) {
+			type_ast = zend_ast_list_add(type_ast, zp_type_to_ast(*type_ptr));
+		} ZEND_TYPE_LIST_FOREACH_END();
+		ZEND_ASSERT(!ZEND_TYPE_PURE_MASK(type));
+		return type_ast;
+	}
+
+	if (ZEND_TYPE_HAS_NAME(type)) {
+		zend_ast *type_ast = zp_type_name_to_ast(
+				zend_string_copy(ZEND_TYPE_NAME(type)));
+		return type_ast;
+	}
+
+	ZEND_ASSERT(!ZEND_TYPE_IS_COMPLEX(type));
+
+	uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
+	ZEND_ASSERT(zp_is_single_may_be_type(type_mask));
+
+	return zp_single_may_be_type_to_ast(type_mask);
+}
+
+static zend_result zp_get_param_default_value(zval *result, zend_function *function, uint32_t arg_offset)
+{
+	ZEND_ASSERT(arg_offset < function->op_array.last);
+
+	if (function->type == ZEND_USER_FUNCTION) {
+		zend_op *opline = &function->op_array.opcodes[arg_offset];
+		if (EXPECTED(opline->opcode == ZEND_RECV_INIT)) {
+			ZVAL_COPY(result, RT_CONSTANT(opline, opline->op2));
+			return SUCCESS;
+		} else {
+			ZEND_ASSERT(opline->opcode == ZEND_RECV);
+		}
+	} else if (function->type == ZEND_INTERNAL_FUNCTION) {
+		if (function->common.fn_flags & ZEND_ACC_USER_ARG_INFO) {
+			goto error;
+		}
+
+		zend_internal_arg_info *arg_info = &function->internal_function.arg_info[arg_offset];
+
+		if (zend_get_default_from_internal_arg_info(result, arg_info) == SUCCESS) {
+			return SUCCESS;
+		}
+	}
+
+error:
+	zend_argument_error(zend_ce_argument_count_error, arg_offset + 1,
+			"must be passed explicitly, because the default value is not known");
+
+	return FAILURE;
+}
+
+static bool zp_arg_must_be_sent_by_ref(zend_function *function, uint32_t arg_num)
+{
+	if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) {
+		if (QUICK_ARG_MUST_BE_SENT_BY_REF(function, arg_num)) {
+			return true;
+		}
+	} else if (ARG_MUST_BE_SENT_BY_REF(function, arg_num)) {
+		return true;
+	}
+	return false;
+}
+
+static zend_ast *zp_attribute_to_ast(zend_attribute *attribute)
+{
+	zend_ast *args_ast;
+	if (attribute->argc) {
+		args_ast = zend_ast_create_arg_list(0, ZEND_AST_ARG_LIST);
+		for (uint32_t i = 0; i < attribute->argc; i++) {
+			zend_ast *arg_ast = zend_ast_create_zval(&attribute->args[i].value);
+			if (attribute->args[i].name) {
+				arg_ast = zend_ast_create(ZEND_AST_NAMED_ARG,
+						zend_ast_create_zval_from_str(
+							zend_string_copy(attribute->args[i].name)),
+						arg_ast);
+			}
+			args_ast = zend_ast_list_add(args_ast, arg_ast);
+		}
+	} else {
+		args_ast = NULL;
+	}
+	return zend_ast_create(ZEND_AST_ATTRIBUTE,
+			zend_ast_create_zval_from_str(zend_string_copy(attribute->name)),
+			args_ast);
+}
+
+static zend_ast *zp_param_attributes_to_ast(zend_function *function,
+		uint32_t offset)
+{
+	zend_ast *attributes_ast = NULL;
+	if (!function->common.attributes) {
+		return NULL;
+	}
+
+	/* Inherit the SensitiveParameter attribute */
+	zend_attribute *attr = zend_get_parameter_attribute_str(
+			function->common.attributes,
+			"sensitiveparameter", strlen("sensitiveparameter"), offset);
+	if (attr) {
+		attributes_ast = zend_ast_create_list(1, ZEND_AST_ATTRIBUTE_GROUP,
+				zp_attribute_to_ast(attr));
+		attributes_ast = zend_ast_create_list(1, ZEND_AST_ATTRIBUTE_LIST,
+				attributes_ast);
+	}
+
+	return attributes_ast;
+}
+
+zend_ast *zp_compile_forwarding_call(
+	zval *this_ptr, zend_function *function,
+	uint32_t argc, zval *argv, zend_array *extra_named_params,
+	zend_string **param_names, bool variadic_partial, uint32_t num_args,
+	zend_class_entry *called_scope, zend_type return_type,
+	bool forward_superfluous_args,
+	zend_ast *stmts_ast)
+{
+	/* Generate function body */
+	zend_ast *args_ast = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+	for (uint32_t offset = 0; offset < argc; offset++) {
+		if (Z_ISUNDEF(argv[offset])) {
+			/* Argument was not passed. Pass its default value. */
+			if (offset < function->common.required_num_args) {
+				zend_argument_error(zend_ce_argument_count_error, offset + 1, "not passed");
+				/* TODO: cleanup */
+				return NULL;
+			}
+			zval default_value;
+			if (zp_get_param_default_value(&default_value, function, offset) == FAILURE) {
+				/* TODO: cleanup */
+				return NULL;
+			}
+			zend_ast *default_value_ast;
+			if (Z_TYPE(default_value) == IS_CONSTANT_AST) {
+				default_value_ast = zend_ast_dup(Z_ASTVAL(default_value));
+			} else {
+				default_value_ast = zend_ast_create_zval(&default_value);
+			}
+			args_ast = zend_ast_list_add(args_ast, default_value_ast);
+		} else {
+			args_ast = zend_ast_list_add(args_ast, zend_ast_create(ZEND_AST_VAR,
+						zend_ast_create_zval_from_str(zend_string_copy(param_names[offset]))));
+		}
+	}
+	if (extra_named_params) {
+		args_ast = zend_ast_list_add(args_ast, zend_ast_create(ZEND_AST_UNPACK,
+					zend_ast_create(ZEND_AST_VAR,
+						zend_ast_create_zval_from_str(zend_string_copy(param_names[argc + variadic_partial])))));
+	}
+	if (variadic_partial) {
+		if (function->common.fn_flags & ZEND_ACC_VARIADIC) {
+			args_ast = zend_ast_list_add(args_ast, zend_ast_create(ZEND_AST_UNPACK,
+						zend_ast_create(ZEND_AST_VAR,
+							zend_ast_create_zval_from_str(zend_string_copy(param_names[argc])))));
+		} else if (forward_superfluous_args) {
+			/* When a '...' placeholder is used, and the underlying function is
+			 * not variadic, superfluous arguments are forwarded.
+			 * Add a ...array_slice(func_get_args(), n) argument, which should
+			 * be compiled as ZEND_AST_UNPACK + ZEND_FUNC_GET_ARGS. */
+
+			zend_ast *func_get_args_name_ast = zend_ast_create_zval_from_str(
+					zend_string_copy(ZSTR_KNOWN(ZEND_STR_FUNC_GET_ARGS)));
+			func_get_args_name_ast->attr = ZEND_NAME_FQ;
+
+			zend_ast *array_slice_name_ast = zend_ast_create_zval_from_str(
+					zend_string_copy(ZSTR_KNOWN(ZEND_STR_ARRAY_SLICE)));
+			array_slice_name_ast->attr = ZEND_NAME_FQ;
+
+			args_ast = zend_ast_list_add(args_ast,
+				zend_ast_create(ZEND_AST_UNPACK,
+					zend_ast_create(ZEND_AST_CALL,
+							array_slice_name_ast,
+							zend_ast_create_list(2, ZEND_AST_ARG_LIST,
+								zend_ast_create(ZEND_AST_CALL,
+									func_get_args_name_ast,
+									zend_ast_create_list(0, ZEND_AST_ARG_LIST)),
+								zend_ast_create_zval_from_long(num_args)))));
+		}
+	}
+
+	zend_ast *call_ast;
+	if (function->common.fn_flags & ZEND_ACC_CLOSURE) {
+		zend_ast *fn_ast = zend_ast_create(ZEND_AST_VAR,
+					zend_ast_create_zval_from_str(zend_string_copy(param_names[argc + variadic_partial + (extra_named_params != NULL)])));
+		call_ast = zend_ast_create(ZEND_AST_CALL, fn_ast, args_ast);
+	} else if (Z_TYPE_P(this_ptr) == IS_OBJECT) {
+		zend_ast *this_ast = zend_ast_create(ZEND_AST_VAR,
+					zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_THIS)));
+		zend_ast *method_name_ast = zend_ast_create_zval_from_str(
+				zend_string_copy(function->common.function_name));
+		call_ast = zend_ast_create(ZEND_AST_METHOD_CALL, this_ast,
+				method_name_ast, args_ast);
+	} else if (called_scope) {
+		zend_ast *class_name_ast = zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_STATIC));
+		class_name_ast->attr = ZEND_NAME_NOT_FQ;
+		zend_ast *method_name_ast = zend_ast_create_zval_from_str(
+				zend_string_copy(function->common.function_name));
+		call_ast = zend_ast_create(ZEND_AST_STATIC_CALL, class_name_ast,
+				method_name_ast, args_ast);
+	} else {
+		zend_ast *func_name_ast = zend_ast_create_zval_from_str(zend_string_copy(function->common.function_name));
+		func_name_ast->attr = ZEND_NAME_FQ;
+		call_ast = zend_ast_create(ZEND_AST_CALL, func_name_ast, args_ast);
+	}
+
+	/* Void functions can not 'return $expr' */
+	if (ZEND_TYPE_FULL_MASK(return_type) & MAY_BE_VOID) {
+		stmts_ast = zend_ast_list_add(stmts_ast, call_ast);
+	} else {
+		zend_ast *return_ast = zend_ast_create(ZEND_AST_RETURN, call_ast);
+		stmts_ast = zend_ast_list_add(stmts_ast, return_ast);
+	}
+
+	return stmts_ast;
+}
+
+zend_op_array *zp_compile(zval *this_ptr, zend_function *function,
+		uint32_t argc, zval *argv, zend_array *extra_named_params,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline, void **cache_slot) {
+
+	zend_class_entry *called_scope;
+
+	if (Z_TYPE_P(this_ptr) == IS_OBJECT) {
+		called_scope = Z_OBJCE_P(this_ptr);
+	} else {
+		called_scope = Z_CE_P(this_ptr);
+	}
+
+	if (EXPECTED(cache_slot[0] == function)) {
+		return cache_slot[1];
+	}
+
+	zend_op_array *op_array = zend_accel_pfa_cache_get(declaring_op_array,
+			declaring_opline, function);
+
+	if (EXPECTED(op_array)) {
+		cache_slot[0] = function;
+		cache_slot[1] = op_array;
+		return op_array;
+	}
+
+	zend_arena *orig_ast_arena = CG(ast_arena);
+	CG(ast_arena) = zend_arena_create(1024 * 32);
+
+	int orig_lineno = CG(zend_lineno);
+	CG(zend_lineno) = zend_get_executed_lineno();
+
+	zend_ast *params_ast = zend_ast_create_list(0, ZEND_AST_ARG_LIST);
+	zend_ast *lexical_vars_ast = zend_ast_create_list(0, ZEND_AST_CLOSURE_USES);
+
+	zend_ast *stmts_ast = zend_ast_create_list(0, ZEND_AST_STMT_LIST);
+
+	bool variadic_partial = false;
+	int new_argc = argc;
+
+	/* Z_EXTRA(ZEND_CALL_ARG(call, 1)) is set in ZEND_SEND_PLACEHOLDER */
+	if (Z_EXTRA(argv[0]) == _IS_PLACEHOLDER_VARIADIC) {
+		variadic_partial = true;
+		new_argc = MAX(new_argc, function->common.num_args);
+	}
+
+	zval *tmp = zend_arena_alloc(&CG(arena), new_argc * sizeof(zval));
+	memcpy(tmp, argv, new_argc * sizeof(zval));
+	argv = tmp;
+
+	if (variadic_partial) {
+		/* All unspecified parameters become placeholders */
+		for (uint32_t i = 0; i < argc; i++) {
+			if (Z_ISUNDEF(argv[i])) {
+				Z_TYPE_INFO(argv[i]) = _IS_PLACEHOLDER_ARG;
+			}
+		}
+		for (uint32_t i = argc; i < new_argc; i++) {
+			Z_TYPE_INFO(argv[i]) = _IS_PLACEHOLDER_ARG;
+		}
+	}
+
+	argc = new_argc;
+
+	/* Assign param names */
+	uint32_t num_names = argc + variadic_partial + (extra_named_params != NULL)
+		+ ((function->common.fn_flags & ZEND_ACC_CLOSURE) != 0);
+	zend_string **param_names = zend_arena_alloc(&CG(arena),
+			sizeof(zend_string*) * num_names);
+	memset(param_names, 0, sizeof(zend_string*) * num_names);
+	zp_assign_names(param_names, num_names, argc, argv, function,
+			variadic_partial, extra_named_params);
+
+	/* Compute number of required args */
+	uint32_t num_args = 0, num_required = 0;
+	for (uint32_t offset = 0; offset < argc; offset++) {
+		if (!Z_IS_PLACEHOLDER_P(&argv[offset])) {
+			continue;
+		}
+		if (offset < function->common.num_args) {
+			num_args++;
+			if (offset < function->common.required_num_args) {
+				num_required = num_args;
+			}
+		} else {
+			ZEND_ASSERT(function->common.fn_flags & ZEND_ACC_VARIADIC);
+			num_args++;
+			/* Placeholders that run into the variadic portion become
+			 * required and make all params before them required */
+			num_required = num_args;
+		}
+	}
+
+	/* Generate params and lexical vars AST */
+	uint32_t arg_num = 0;
+	for (uint32_t offset = 0; offset < argc; offset++) {
+		if (Z_IS_PLACEHOLDER_P(&argv[offset])) {
+			arg_num++;
+			if (offset < function->common.num_args) {
+				zend_arg_info *arg_info = &function->common.arg_info[offset];
+				int param_flags = 0;
+				if (zp_arg_must_be_sent_by_ref(function, offset+1)) {
+					param_flags |= ZEND_PARAM_REF;
+				}
+				zend_ast *param_type_ast = zp_type_to_ast(arg_info->type);
+				zend_ast *default_value_ast = NULL;
+				if (arg_num > num_required) {
+					zval default_value;
+					if (zp_get_param_default_value(&default_value, function, offset) == FAILURE) {
+						return NULL;
+					}
+					default_value_ast = zend_ast_create_zval(&default_value);
+				}
+				zend_ast *attributes_ast = zp_param_attributes_to_ast(function, offset);
+				params_ast = zend_ast_list_add(params_ast, zend_ast_create_ex(ZEND_AST_PARAM,
+						param_flags, param_type_ast,
+						zend_ast_create_zval_from_str(param_names[offset]),
+						default_value_ast, attributes_ast, NULL, NULL));
+			} else {
+				ZEND_ASSERT(function->common.fn_flags & ZEND_ACC_VARIADIC);
+				zend_arg_info *arg_info = &function->common.arg_info[function->common.num_args];
+				int param_flags = 0;
+				if (zp_arg_must_be_sent_by_ref(function, offset+1)) {
+					param_flags |= ZEND_PARAM_REF;
+				}
+				zend_ast *param_type_ast = zp_type_to_ast(arg_info->type);
+				params_ast = zend_ast_list_add(params_ast, zend_ast_create_ex(ZEND_AST_PARAM,
+						param_flags, param_type_ast,
+						zend_ast_create_zval_from_str(param_names[offset]),
+						NULL, NULL, NULL, NULL));
+			}
+		} else if (!Z_ISUNDEF(argv[offset])) {
+			// TODO: If the pre-bound parameter is a literal, it can be a
+			// literal in the function body instead of a lexical var.
+			zend_ast *lexical_var_ast = zend_ast_create_zval_from_str(param_names[offset]);
+			if (zp_arg_must_be_sent_by_ref(function, offset+1)) {
+				lexical_var_ast->attr = ZEND_BIND_REF;
+			}
+			lexical_vars_ast = zend_ast_list_add(
+					lexical_vars_ast, lexical_var_ast);
+		}
+	}
+
+	if (extra_named_params) {
+		zend_ast *lexical_var_ast = zend_ast_create_zval_from_str(param_names[argc + variadic_partial]);
+		lexical_vars_ast = zend_ast_list_add(lexical_vars_ast, lexical_var_ast);
+	}
+
+	if (function->common.fn_flags & ZEND_ACC_CLOSURE) {
+		zend_ast *lexical_var_ast = zend_ast_create_zval_from_str(param_names[argc + variadic_partial + (extra_named_params != NULL)]);
+		lexical_vars_ast = zend_ast_list_add(lexical_vars_ast, lexical_var_ast);
+	}
+
+	/* If we have a variadic placeholder and the underlying function is
+	 * variadic, add a variadic param. */
+	if (variadic_partial
+			&& (function->common.fn_flags & ZEND_ACC_VARIADIC)) {
+		zend_arg_info *arg_info = &function->common.arg_info[function->common.num_args];
+		int param_flags = ZEND_PARAM_VARIADIC;
+		if (zp_arg_must_be_sent_by_ref(function, function->common.num_args+1)) {
+			param_flags |= ZEND_PARAM_REF;
+		}
+		zend_ast *param_type_ast = zp_type_to_ast(arg_info->type);
+		params_ast = zend_ast_list_add(params_ast, zend_ast_create_ex(ZEND_AST_PARAM,
+				param_flags, param_type_ast,
+				zend_ast_create_zval_from_str(param_names[argc]),
+				NULL, NULL, NULL, NULL));
+	}
+
+	zend_ast *return_type_ast = NULL;
+	zend_type return_type = {0};
+	if (function->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
+		return_type = (function->common.arg_info-1)->type;
+		return_type_ast = zp_type_to_ast(return_type);
+	}
+
+	/**
+	 * Generate function body.
+	 *
+	 * If we may need to forward superflous arguments, do that conditionally, as
+	 * it's faster:
+	 *
+	 * if (func_num_args() <= n) {
+	 *    // normal call
+	 * } else {
+	 *    // call with superflous arg forwarding
+	 * }
+	 *
+	 * The func_num_args() call should be compiled to a single FUNC_NUM_ARGS op.
+	 */
+	if (variadic_partial && !(function->common.fn_flags & ZEND_ACC_VARIADIC)) {
+		zend_ast *no_forwarding_ast = zend_ast_create_list(0, ZEND_AST_STMT_LIST);
+		zend_ast *forwarding_ast = zend_ast_create_list(0, ZEND_AST_STMT_LIST);
+
+		no_forwarding_ast = zp_compile_forwarding_call(this_ptr, function,
+				argc, argv, extra_named_params,
+				param_names, variadic_partial, num_args,
+				called_scope, return_type, false, no_forwarding_ast);
+
+		if (!no_forwarding_ast) {
+			/* TODO: proper cleanup */
+			goto clean_argv;
+		}
+
+		forwarding_ast = zp_compile_forwarding_call(this_ptr, function,
+				argc, argv, extra_named_params,
+				param_names, variadic_partial, num_args,
+				called_scope, return_type, true, forwarding_ast);
+
+		if (!forwarding_ast) {
+			/* TODO: proper cleanup */
+			goto clean_argv;
+		}
+
+		zend_ast *func_num_args_name_ast = zend_ast_create_zval_from_str(
+				zend_string_copy(ZSTR_KNOWN(ZEND_STR_FUNC_NUM_ARGS)));
+		func_num_args_name_ast->attr = ZEND_NAME_FQ;
+
+		stmts_ast = zend_ast_list_add(stmts_ast,
+			zend_ast_create_list(2, ZEND_AST_IF,
+				zend_ast_create(ZEND_AST_IF_ELEM,
+					zend_ast_create_binary_op(ZEND_IS_SMALLER_OR_EQUAL,
+						zend_ast_create(ZEND_AST_CALL, func_num_args_name_ast,
+							zend_ast_create_list(0, ZEND_AST_ARG_LIST)),
+						zend_ast_create_zval_from_long(num_args)),
+					no_forwarding_ast),
+				zend_ast_create(ZEND_AST_IF_ELEM,
+					NULL,
+					forwarding_ast)));
+	} else {
+		stmts_ast = zp_compile_forwarding_call(this_ptr, function,
+				argc, argv, extra_named_params,
+				param_names, variadic_partial, num_args,
+				called_scope, return_type, false, stmts_ast);
+
+		if (!stmts_ast) {
+			/* TODO: proper cleanup */
+			goto clean_argv;
+		}
+	}
+
+	/* Inherit the NoDiscard attribute */
+	zend_ast *attributes_ast = NULL;
+	if (function->common.attributes) {
+		zend_attribute *attr = zend_get_attribute_str(
+				function->common.attributes, "nodiscard", strlen("nodiscard"));
+		if (attr) {
+			attributes_ast = zend_ast_create_list(1, ZEND_AST_ATTRIBUTE_GROUP,
+					zp_attribute_to_ast(attr));
+			attributes_ast = zend_ast_create_list(1, ZEND_AST_ATTRIBUTE_LIST,
+					attributes_ast);
+		}
+	}
+
+	int closure_flags = 0;
+	zend_ast *closure_ast = zend_ast_create_decl(ZEND_AST_CLOSURE,
+			closure_flags, CG(zend_lineno), NULL,
+			NULL, params_ast, lexical_vars_ast, stmts_ast,
+			return_type_ast, attributes_ast);
+
+	if (Z_TYPE_P(this_ptr) != IS_OBJECT || IS_STATIC_CLOSURE(function)) {
+		((zend_ast_decl*)closure_ast)->flags |= ZEND_ACC_STATIC;
+	}
+
+#if ZEND_DEBUG
+	{
+		const char *tmp = getenv("DUMP_PFA_AST");
+		if (tmp && ZEND_ATOL(tmp)) {
+			zend_string *str = zend_ast_export("", closure_ast, "");
+			fprintf(stderr, "PFA AST: %s\n", ZSTR_VAL(str));
+			zend_string_release(str);
+		}
+	}
+#endif
+
+	op_array = zend_accel_compile_pfa(closure_ast, declaring_op_array,
+			declaring_opline, function);
+
+	zend_ast_destroy(closure_ast);
+
+clean_argv:
+	zend_arena_destroy(CG(ast_arena));
+	CG(ast_arena) = orig_ast_arena;
+	CG(zend_lineno) = orig_lineno;
+
+	if (op_array) {
+		cache_slot[0] = function;
+		cache_slot[1] = op_array;
+	}
+
+	return op_array;
+}
+
+zend_op_array *zp_get_op_array(zval *this_ptr, zend_function *function,
+		uint32_t argc, zval *argv, zend_array *extra_named_params,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline, void **cache_slot) {
+
+	if (EXPECTED(cache_slot[0] == function)) {
+		return cache_slot[1];
+	}
+
+	zend_op_array *op_array = zend_accel_pfa_cache_get(declaring_op_array,
+			declaring_opline, function);
+
+	if (EXPECTED(op_array)) {
+		cache_slot[0] = function;
+		cache_slot[1] = op_array;
+		return op_array;
+	}
+
+	return zp_compile(this_ptr, function, argc, argv,
+			extra_named_params, declaring_op_array, declaring_opline,
+			cache_slot);
+}
+
+/* Bind pre-bound arguments as lexical vars */
+void zp_bind(zval *result, zend_function *function, uint32_t argc, zval *argv,
+		zend_array *extra_named_params) {
+
+	zend_arg_info *arg_infos = function->common.arg_info;
+	uint32_t bind_offset = 0;
+	for (uint32_t offset = 0; offset < argc; offset++) {
+		zval *var = &argv[offset];
+		if (Z_IS_PLACEHOLDER_P(var) || Z_ISUNDEF_P(var)) {
+			continue;
+		}
+		zend_arg_info *arg_info;
+		if (offset < function->common.num_args) {
+			arg_info = &arg_infos[offset];
+		} else if (function->common.fn_flags & ZEND_ACC_VARIADIC) {
+			arg_info = &arg_infos[function->common.num_args];
+		} else {
+			arg_info = NULL;
+		}
+		if (arg_info && ZEND_TYPE_IS_SET(arg_info->type)
+				&& UNEXPECTED(!zend_check_type_ex(&arg_info->type, var, function->common.scope, 0, 0))) {
+			zend_verify_arg_error(function, arg_info, offset+1, var);
+			zval_ptr_dtor(result);
+			ZVAL_NULL(result);
+			return;
+		}
+		ZEND_ASSERT(zp_arg_must_be_sent_by_ref(function, offset+1) ? Z_ISREF_P(var) : !Z_ISREF_P(var));
+		zend_closure_bind_var_ex(result, bind_offset, var);
+		bind_offset += sizeof(Bucket);
+	}
+
+	if (extra_named_params) {
+		zval var;
+		ZVAL_ARR(&var, extra_named_params);
+		Z_ADDREF(var);
+		zend_closure_bind_var_ex(result, bind_offset, &var);
+		bind_offset += sizeof(Bucket);
+	}
+
+	if (function->common.fn_flags & ZEND_ACC_CLOSURE) {
+		zval var;
+		ZVAL_OBJ(&var, ZEND_CLOSURE_OBJECT(function));
+		Z_ADDREF(var);
+		zend_closure_bind_var_ex(result, bind_offset, &var);
+	}
+}
+
+void zend_partial_create(zval *result, zval *this_ptr, zend_function *function,
+		uint32_t argc, zval *argv, zend_array *extra_named_params,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline, void **cache_slot) {
+
+	zend_op_array *op_array = zp_get_op_array(this_ptr, function, argc, argv,
+			extra_named_params, declaring_op_array, declaring_opline,
+			cache_slot);
+
+	if (UNEXPECTED(!op_array)) {
+		ZEND_ASSERT(EG(exception));
+		return;
+	}
+
+	zend_class_entry *called_scope;
+	zval object;
+
+	if (Z_TYPE_P(this_ptr) == IS_OBJECT) {
+		called_scope = Z_OBJCE_P(this_ptr);
+	} else {
+		called_scope = Z_CE_P(this_ptr);
+	}
+
+	if (Z_TYPE_P(this_ptr) == IS_OBJECT && !IS_STATIC_CLOSURE(function)) {
+		ZVAL_COPY_VALUE(&object, this_ptr);
+	} else {
+		ZVAL_UNDEF(&object);
+	}
+
+	zend_create_partial_closure(result, (zend_function*)op_array,
+			function->common.scope, called_scope, &object);
+
+	destroy_op_array(op_array);
+
+	zp_bind(result, function, argc, argv, extra_named_params);
+}
diff --git a/Zend/zend_partial.h b/Zend/zend_partial.h
new file mode 100644
index 0000000000000..0d4e6653987c1
--- /dev/null
+++ b/Zend/zend_partial.h
@@ -0,0 +1,37 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: krakjoe <krakjoe@php.net>                                   |
+   +----------------------------------------------------------------------+
+*/
+#ifndef ZEND_PARTIAL_H
+#define ZEND_PARTIAL_H
+
+#include "zend_types.h"
+#include "zend_API.h"
+
+BEGIN_EXTERN_C()
+
+void zend_partial_startup(void);
+
+void zend_partial_create(zval *result, zval *this_ptr, zend_function *function,
+		uint32_t argc, zval *argv, zend_array *extra_named_params,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline, void **cache_slot);
+
+void zend_partial_args_check(zend_execute_data *call);
+
+END_EXTERN_C()
+
+#endif
diff --git a/Zend/zend_string.h b/Zend/zend_string.h
index 87f221125202c..94dd99cdc4f15 100644
--- a/Zend/zend_string.h
+++ b/Zend/zend_string.h
@@ -630,6 +630,9 @@ EMPTY_SWITCH_DEFAULT_CASE()
 	_(ZEND_STR_AUTOGLOBAL_ENV,         "_ENV") \
 	_(ZEND_STR_AUTOGLOBAL_REQUEST,     "_REQUEST") \
 	_(ZEND_STR_COUNT,                  "count") \
+	_(ZEND_STR_FUNC_NUM_ARGS,          "func_num_args") \
+	_(ZEND_STR_FUNC_GET_ARGS,          "func_get_args") \
+	_(ZEND_STR_ARRAY_SLICE,            "array_slice") \
 	_(ZEND_STR_SENSITIVEPARAMETER,     "SensitiveParameter") \
 	_(ZEND_STR_CONST_EXPR_PLACEHOLDER, "[constant expression]") \
 	_(ZEND_STR_DEPRECATED_CAPITALIZED, "Deprecated") \
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index a3d3e4da6362d..0b57d1b4341d8 100644
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -649,6 +649,10 @@ struct _zend_ast_ref {
 #define _IS_BOOL					18
 #define _IS_NUMBER					19
 
+/* used for place holders */
+#define _IS_PLACEHOLDER_ARG         20
+#define _IS_PLACEHOLDER_VARIADIC    21
+
 /* guard flags */
 #define ZEND_GUARD_PROPERTY_GET		(1<<0)
 #define ZEND_GUARD_PROPERTY_SET		(1<<1)
@@ -866,6 +870,7 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) {
 
 #define IS_OBJ_LAZY_UNINITIALIZED   (1U<<31) /* Virtual proxy or uninitialized Ghost */
 #define IS_OBJ_LAZY_PROXY           (1U<<30) /* Virtual proxy (may be initialized) */
+#define OBJ_EXTRA_FLAG_PRIV_1       (1U<<29) /* Reserved for private use by the object itself */
 
 #define OBJ_EXTRA_FLAGS(obj)		((obj)->extra_flags)
 
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 3d6463d064873..0f5c3b82cbc59 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2979,6 +2979,7 @@ ZEND_VM_HOT_HELPER(zend_leave_helper, ANY, ANY)
 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
 		}
+
 		EG(vm_stack_top) = (zval*)execute_data;
 		execute_data = EX(prev_execute_data);
 
@@ -9215,6 +9216,45 @@ ZEND_VM_HANDLER(200, ZEND_FETCH_GLOBALS, UNUSED, UNUSED)
 	ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(211, ZEND_SEND_PLACEHOLDER, UNUSED, CONST|UNUSED)
+{
+	USE_OPLINE
+	zval *arg;
+	zend_execute_data *call = EX(call);
+
+	if (OP2_TYPE == IS_CONST) {
+		SAVE_OPLINE();
+		zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+		uint32_t arg_num;
+		arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
+		if (UNEXPECTED(!arg)) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	} else if (opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+		Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) = _IS_PLACEHOLDER_VARIADIC;
+	} else {
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(213, ZEND_CHECK_PARTIAL_ARGS, UNUSED, UNUSED)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+
+	SAVE_OPLINE();
+	zend_partial_args_check(call);
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 ZEND_VM_HANDLER(186, ZEND_ISSET_ISEMPTY_THIS, UNUSED, UNUSED)
 {
 	USE_OPLINE
@@ -9717,6 +9757,42 @@ ZEND_VM_HANDLER(202, ZEND_CALLABLE_CONVERT, UNUSED, UNUSED)
 	ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(212, ZEND_CALLABLE_CONVERT_PARTIAL, NUM, UNUSED, CACHE_SLOT)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_execute_data *call = EX(call);
+	void **cache_slot = CACHE_ADDR(opline->op1.num);
+
+	zend_partial_create(EX_VAR(opline->result.var),
+		&call->This, call->func,
+		ZEND_CALL_NUM_ARGS(call), ZEND_CALL_ARG(call, 1),
+		ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS ?
+			call->extra_named_params : NULL,
+		&EX(func)->op_array, opline, cache_slot);
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
+		zend_array_release(call->extra_named_params);
+	}
+
+	if ((call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
+		zend_free_trampoline(call->func);
+	}
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
+		OBJ_RELEASE(Z_OBJ(call->This));
+	} else if (ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE) {
+		OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
+	}
+
+	EX(call) = call->prev_execute_data;
+
+	zend_vm_stack_free_call_frame(call);
+
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 ZEND_VM_HANDLER(208, ZEND_JMP_FRAMELESS, CONST, JMP_ADDR, NUM|CACHE_SLOT)
 {
 	USE_OPLINE
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 92e5f327fd08a..2788ee6fd9f2e 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1198,6 +1198,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV
 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
 		}
+
 		EG(vm_stack_top) = (zval*)execute_data;
 		execute_data = EX(prev_execute_data);
 
@@ -4395,6 +4396,42 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RECV_VARIADIC
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_execute_data *call = EX(call);
+	void **cache_slot = CACHE_ADDR(opline->op1.num);
+
+	zend_partial_create(EX_VAR(opline->result.var),
+		&call->This, call->func,
+		ZEND_CALL_NUM_ARGS(call), ZEND_CALL_ARG(call, 1),
+		ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS ?
+			call->extra_named_params : NULL,
+		&EX(func)->op_array, opline, cache_slot);
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
+		zend_array_release(call->extra_named_params);
+	}
+
+	if ((call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
+		zend_free_trampoline(call->func);
+	}
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
+		OBJ_RELEASE(Z_OBJ(call->This));
+	} else if (ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE) {
+		OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
+	}
+
+	EX(call) = call->prev_execute_data;
+
+	zend_vm_stack_free_call_frame(call);
+
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -36289,6 +36326,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_UN
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *arg;
+	zend_execute_data *call = EX(call);
+
+	if (IS_CONST == IS_CONST) {
+		SAVE_OPLINE();
+		zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+		uint32_t arg_num;
+		arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
+		if (UNEXPECTED(!arg)) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	} else if (opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+		Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) = _IS_PLACEHOLDER_VARIADIC;
+	} else {
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	zend_class_entry *ce, *scope;
@@ -38891,6 +38957,45 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_GLOBALS
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *arg;
+	zend_execute_data *call = EX(call);
+
+	if (IS_UNUSED == IS_CONST) {
+		SAVE_OPLINE();
+		zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+		uint32_t arg_num;
+		arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
+		if (UNEXPECTED(!arg)) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	} else if (opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+		Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) = _IS_PLACEHOLDER_VARIADIC;
+	} else {
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+
+	SAVE_OPLINE();
+	zend_partial_args_check(call);
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -56677,6 +56782,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV  zend
 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
 		}
+
 		EG(vm_stack_top) = (zval*)execute_data;
 		execute_data = EX(prev_execute_data);
 
@@ -59758,6 +59864,42 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RECV_VARIADIC_SPEC
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_execute_data *call = EX(call);
+	void **cache_slot = CACHE_ADDR(opline->op1.num);
+
+	zend_partial_create(EX_VAR(opline->result.var),
+		&call->This, call->func,
+		ZEND_CALL_NUM_ARGS(call), ZEND_CALL_ARG(call, 1),
+		ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS ?
+			call->extra_named_params : NULL,
+		&EX(func)->op_array, opline, cache_slot);
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
+		zend_array_release(call->extra_named_params);
+	}
+
+	if ((call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
+		zend_free_trampoline(call->func);
+	}
+
+	if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) {
+		OBJ_RELEASE(Z_OBJ(call->This));
+	} else if (ZEND_CALL_INFO(call) & ZEND_CALL_CLOSURE) {
+		OBJ_RELEASE(ZEND_CLOSURE_OBJECT(call->func));
+	}
+
+	EX(call) = call->prev_execute_data;
+
+	zend_vm_stack_free_call_frame(call);
+
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -91450,6 +91592,35 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_UNUSED_
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *arg;
+	zend_execute_data *call = EX(call);
+
+	if (IS_CONST == IS_CONST) {
+		SAVE_OPLINE();
+		zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+		uint32_t arg_num;
+		arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
+		if (UNEXPECTED(!arg)) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	} else if (opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+		Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) = _IS_PLACEHOLDER_VARIADIC;
+	} else {
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	zend_class_entry *ce, *scope;
@@ -94052,6 +94223,45 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_GLOBALS_SPEC
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *arg;
+	zend_execute_data *call = EX(call);
+
+	if (IS_UNUSED == IS_CONST) {
+		SAVE_OPLINE();
+		zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+		uint32_t arg_num;
+		arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num));
+		if (UNEXPECTED(!arg)) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	} else if (opline->op1.num == _IS_PLACEHOLDER_VARIADIC) {
+		Z_EXTRA_P(ZEND_CALL_ARG(call, 1)) = _IS_PLACEHOLDER_VARIADIC;
+	} else {
+		ZEND_ASSERT(opline->op1.num == _IS_PLACEHOLDER_ARG);
+		arg = ZEND_CALL_VAR(EX(call), opline->result.var);
+		Z_TYPE_INFO_P(arg) = _IS_PLACEHOLDER_ARG;
+		Z_EXTRA_P(arg) = 0;
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+
+	SAVE_OPLINE();
+	zend_partial_args_check(call);
+	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -114643,6 +114853,13 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
 			(void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
 			(void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL,
+			(void*)&&ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
+			(void*)&&ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
+			(void*)&&ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_LABEL,
+			(void*)&&ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_LABEL,
 			(void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
 			(void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
@@ -115691,6 +115908,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 		} else if (UNEXPECTED(call_info & ZEND_CALL_CLOSURE)) {
 			OBJ_RELEASE(ZEND_CLOSURE_OBJECT(EX(func)));
 		}
+
 		EG(vm_stack_top) = (zval*)execute_data;
 		execute_data = EX(prev_execute_data);
 
@@ -116067,6 +116285,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_RECV_VARIADIC_SPEC_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED):
+				VM_TRACE(ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED)
+				ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED):
 				VM_TRACE(ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED)
 				ZEND_FRAMELESS_ICALL_1_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -119544,6 +119767,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_CONST)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST):
+				VM_TRACE(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST)
+				ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV):
 				VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV)
 				ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -119724,6 +119952,16 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED):
+				VM_TRACE(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED)
+				ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED)
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED):
+				VM_TRACE(ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED)
+				ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED):
 				VM_TRACE(ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED)
 				ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -123894,6 +124132,13 @@ void zend_vm_init(void)
 		ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
 		ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
 		ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER,
+		ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_HANDLER,
+		ZEND_NULL_HANDLER,
+		ZEND_NULL_HANDLER,
+		ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_HANDLER,
+		ZEND_NULL_HANDLER,
+		ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_HANDLER,
+		ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_HANDLER,
 		ZEND_NULL_HANDLER,
@@ -127391,6 +127636,13 @@ void zend_vm_init(void)
 		ZEND_JMP_FRAMELESS_SPEC_CONST_TAILCALL_HANDLER,
 		ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER,
 		ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_TAILCALL_HANDLER,
+		ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST_TAILCALL_HANDLER,
+		ZEND_NULL_TAILCALL_HANDLER,
+		ZEND_NULL_TAILCALL_HANDLER,
+		ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER,
+		ZEND_NULL_TAILCALL_HANDLER,
+		ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED_TAILCALL_HANDLER,
+		ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER,
 		ZEND_NULL_TAILCALL_HANDLER,
@@ -128359,7 +128611,7 @@ void zend_vm_init(void)
 		1255,
 		1256 | SPEC_RULE_OP1,
 		1261 | SPEC_RULE_OP1,
-		3493,
+		3500,
 		1266 | SPEC_RULE_OP1,
 		1271 | SPEC_RULE_OP1,
 		1276 | SPEC_RULE_OP2,
@@ -128393,7 +128645,7 @@ void zend_vm_init(void)
 		1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1584 | SPEC_RULE_OP1,
 		1589,
-		3493,
+		3500,
 		1590 | SPEC_RULE_OP1,
 		1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
@@ -128525,51 +128777,51 @@ void zend_vm_init(void)
 		2575,
 		2576,
 		2577,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
+		2578 | SPEC_RULE_OP2,
+		2583,
+		2584,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
+		3500,
 	};
 #if 0
 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
@@ -128746,7 +128998,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2593 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -128754,7 +129006,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2618 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -128762,7 +129014,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2643 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -128773,17 +129025,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2668 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			} else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2693 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2718 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_MUL:
@@ -128794,17 +129046,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2743 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2768 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2793 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_IDENTICAL:
@@ -128815,16 +129067,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2818 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2893 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
-				spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3118 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
-				spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3124 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_IDENTICAL:
@@ -128835,16 +129087,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2968 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3043 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
-				spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3121 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
-				spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3129 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_EQUAL:
@@ -128855,12 +129107,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2818 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2893 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_EQUAL:
@@ -128871,12 +129123,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2968 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3043 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_SMALLER:
@@ -128884,12 +129136,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3134 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3209 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
@@ -128897,79 +129149,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3284 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3359 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_QM_ASSIGN:
 			if (op1_info == MAY_BE_LONG) {
-				spec = 3439 | SPEC_RULE_OP1;
+				spec = 3446 | SPEC_RULE_OP1;
 			} else if (op1_info == MAY_BE_DOUBLE) {
-				spec = 3444 | SPEC_RULE_OP1;
+				spec = 3451 | SPEC_RULE_OP1;
 			} else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) {
-				spec = 3449 | SPEC_RULE_OP1;
+				spec = 3456 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_PRE_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3427 | SPEC_RULE_RETVAL;
+				spec = 3434 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3429 | SPEC_RULE_RETVAL;
+				spec = 3436 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_PRE_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3431 | SPEC_RULE_RETVAL;
+				spec = 3438 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3433 | SPEC_RULE_RETVAL;
+				spec = 3440 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_POST_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3435;
+				spec = 3442;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3436;
+				spec = 3443;
 			}
 			break;
 		case ZEND_POST_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3437;
+				spec = 3444;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3438;
+				spec = 3445;
 			}
 			break;
 		case ZEND_JMP:
 			if (OP_JMP_ADDR(op, op->op1) > op) {
-				spec = 2585;
+				spec = 2592;
 			}
 			break;
 		case ZEND_INIT_FCALL:
 			if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
-				spec = 2578;
+				spec = 2585;
 			}
 			break;
 		case ZEND_RECV:
 			if (op->op2.num == MAY_BE_ANY) {
-				spec = 2579;
+				spec = 2586;
 			}
 			break;
 		case ZEND_SEND_VAL:
 			if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-				spec = 3489;
+				spec = 3496;
 			}
 			break;
 		case ZEND_SEND_VAR_EX:
 			if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3484 | SPEC_RULE_OP1;
+				spec = 3491 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_FE_FETCH_R:
 			if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
-				spec = 3491 | SPEC_RULE_RETVAL;
+				spec = 3498 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_FETCH_DIM_R:
@@ -128977,22 +129229,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 3461 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_SEND_VAL_EX:
 			if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-				spec = 3490;
+				spec = 3497;
 			}
 			break;
 		case ZEND_SEND_VAR:
 			if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3479 | SPEC_RULE_OP1;
+				spec = 3486 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_COUNT:
 			if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
-				spec = 2580 | SPEC_RULE_OP1;
+				spec = 2587 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_BW_OR:
diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 33d951141550e..498c216f7cf8f 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1373,508 +1373,512 @@
 	_(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \
 	_(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \
 	_(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \
-	_(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
-	_(2579, ZEND_RECV_NOTYPE_SPEC) \
-	_(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
-	_(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
-	_(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
-	_(2585, ZEND_JMP_FORWARD_SPEC) \
-	_(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2578, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_CONST) \
+	_(2581, ZEND_SEND_PLACEHOLDER_SPEC_UNUSED_UNUSED) \
+	_(2583, ZEND_CALLABLE_CONVERT_PARTIAL_SPEC_UNUSED) \
+	_(2584, ZEND_CHECK_PARTIAL_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2585, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
+	_(2586, ZEND_RECV_NOTYPE_SPEC) \
+	_(2588, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2589, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2591, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
+	_(2592, ZEND_JMP_FORWARD_SPEC) \
+	_(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2613, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2614, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2615, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2638, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2639, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2640, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2663, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2664, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2665, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2688, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2690, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2688, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2690, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2694, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2695, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2697, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2713, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2715, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2713, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2714, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2715, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2719, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2720, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2722, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2738, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2739, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2740, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2763, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2764, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2765, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2788, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2789, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2790, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3111, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
-	_(3112, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3113, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3114, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
-	_(3115, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3116, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3117, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3121, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3122, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3126, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3427, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3428, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3429, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3430, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3431, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3432, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3433, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3434, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3435, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3436, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3437, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3438, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3439, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
-	_(3440, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3443, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-	_(3445, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3448, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3449, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-	_(3450, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3453, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(2813, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2814, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2815, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2861, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2890, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2891, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2892, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2936, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2965, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2966, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2967, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3011, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3040, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3041, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3042, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3086, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3115, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3116, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3117, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3118, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
+	_(3119, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3120, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3121, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
+	_(3122, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3123, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3124, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3128, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3129, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3133, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3137, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3138, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3142, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3146, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3147, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3148, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3196, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3197, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3206, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3207, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3271, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3272, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3281, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3282, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3346, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3347, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3356, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3357, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3421, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3422, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3431, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3432, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3434, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3435, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3436, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3437, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3438, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3439, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3440, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3441, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3442, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3443, ZEND_POST_INC_LONG_SPEC_CV) \
+	_(3444, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3445, ZEND_POST_DEC_LONG_SPEC_CV) \
+	_(3446, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
+	_(3447, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3448, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3450, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3451, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+	_(3452, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3453, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3455, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3456, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+	_(3457, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3458, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3460, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
 	_(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-	_(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3481, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-	_(3483, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-	_(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
-	_(3488, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
-	_(3489, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-	_(3490, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-	_(3491, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-	_(3492, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-	_(3492+1, ZEND_NULL)
+	_(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3473, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3481, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+	_(3482, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3483, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3485, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3488, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+	_(3490, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+	_(3493, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
+	_(3495, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
+	_(3496, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+	_(3497, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+	_(3498, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+	_(3499, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+	_(3499+1, ZEND_NULL)
diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 00ad38baaafeb..b54fc6235b12a 100644
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[211] = {
+static const char *zend_vm_opcodes_names[214] = {
 	"ZEND_NOP",
 	"ZEND_ADD",
 	"ZEND_SUB",
@@ -234,9 +234,12 @@ static const char *zend_vm_opcodes_names[211] = {
 	"ZEND_JMP_FRAMELESS",
 	"ZEND_INIT_PARENT_PROPERTY_HOOK_CALL",
 	"ZEND_DECLARE_ATTRIBUTED_CONST",
+	"ZEND_SEND_PLACEHOLDER",
+	"ZEND_CALLABLE_CONVERT_PARTIAL",
+	"ZEND_CHECK_PARTIAL_ARGS",
 };
 
-static uint32_t zend_vm_opcodes_flags[211] = {
+static uint32_t zend_vm_opcodes_flags[214] = {
 	0x00000000,
 	0x00000b0b,
 	0x00000b0b,
@@ -448,6 +451,9 @@ static uint32_t zend_vm_opcodes_flags[211] = {
 	0x01042003,
 	0x01001103,
 	0x00000303,
+	0x00000301,
+	0x00040110,
+	0x00000101,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) {
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 287dec375f3a9..2db8613955af7 100644
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -330,7 +330,10 @@ END_EXTERN_C()
 #define ZEND_JMP_FRAMELESS                  208
 #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209
 #define ZEND_DECLARE_ATTRIBUTED_CONST       210
+#define ZEND_SEND_PLACEHOLDER               211
+#define ZEND_CALLABLE_CONVERT_PARTIAL       212
+#define ZEND_CHECK_PARTIAL_ARGS             213
 
-#define ZEND_VM_LAST_OPCODE                 210
+#define ZEND_VM_LAST_OPCODE                 213
 
 #endif
diff --git a/configure.ac b/configure.ac
index 5059f55127b06..e67ff36f2aaa2 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1784,6 +1784,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([
     zend_observer.c
     zend_opcode.c
     zend_operators.c
+    zend_partial.c
     zend_property_hooks.c
     zend_ptr_stack.c
     zend_signal.c
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index f0d3379534591..133f5d2bd90d7 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -26,7 +26,9 @@
 #include "zend_compile.h"
 #include "ZendAccelerator.h"
 #include "zend_modules.h"
+#include "zend_operators.h"
 #include "zend_persist.h"
+#include "zend_portability.h"
 #include "zend_shared_alloc.h"
 #include "zend_accelerator_module.h"
 #include "zend_accelerator_blacklist.h"
@@ -50,6 +52,7 @@
 #include "zend_system_id.h"
 #include "ext/pcre/php_pcre.h"
 #include "ext/standard/basic_functions.h"
+#include "zend_vm_opcodes.h"
 
 #ifdef ZEND_WIN32
 # include "ext/hash/php_hash.h"
@@ -1992,6 +1995,164 @@ static int check_persistent_script_access(zend_persistent_script *persistent_scr
 	}
 }
 
+static const char hexchars[] = "0123456789abcdef";
+
+static char *accel_uintptr_hex(char *dest, uintptr_t n)
+{
+	char *start = dest;
+	dest += sizeof(uintptr_t)*2;
+
+	while (n > 0) {
+		*--dest = hexchars[n % strlen(hexchars)];
+		n /= strlen(hexchars);
+	}
+	while (dest > start) {
+		*--dest = '0';
+	}
+
+	return dest + sizeof(uintptr_t)*2;
+}
+
+static zend_string *zend_accel_pfa_key(const zend_op *declaring_opline,
+		const zend_function *called_function)
+{
+	size_t key_len = strlen("partial") + (strlen(":")+sizeof(uintptr_t)*2)*2;
+	zend_string *key = zend_string_alloc(key_len, 0);
+	char *dest = ZSTR_VAL(key);
+
+	dest = mempcpy(ZSTR_VAL(key), "partial", strlen("partial"));
+	*dest++ = ':';
+	dest = accel_uintptr_hex(dest, (uintptr_t)declaring_opline);
+	*dest++ = ':';
+	dest = accel_uintptr_hex(dest, (uintptr_t)called_function);
+
+	ZEND_ASSERT(dest == ZSTR_VAL(key) + key_len);
+
+	ZSTR_VAL(key)[key_len] = 0;
+	ZSTR_LEN(key) = key_len;
+
+	return key;
+}
+
+zend_op_array *zend_accel_pfa_cache_get(const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline, const zend_function *called_function)
+{
+	if (!ZCG(accelerator_enabled)) {
+		return NULL;
+	}
+
+	/* The PFA is not cached if either the declaring op array
+	 * or called_function is not cached. */
+
+	if (declaring_op_array->refcount
+			|| (called_function->type == ZEND_USER_FUNCTION && called_function->op_array.refcount)) {
+		return NULL;
+	}
+
+	// TODO: Storing PFAs in ZCSG(hash) is not ideal as this may clash with
+	// legit scripts. Should store PFAs in the declaring_op_array.
+
+	zend_string *key = zend_accel_pfa_key(declaring_opline, called_function);
+	zend_persistent_script *persistent_script =
+		zend_accel_hash_find(&ZCSG(hash), key);
+	zend_string_release(key);
+
+	if (!persistent_script) {
+		return NULL;
+	}
+
+	/* Do not revalidate or check access: this was already validated when
+	 * loading the declaring op array. */
+
+	ZEND_ASSERT(persistent_script->script.main_op_array.num_dynamic_func_defs == 1);
+	return persistent_script->script.main_op_array.dynamic_func_defs[0];
+}
+
+zend_op_array *zend_accel_compile_pfa(zend_ast *ast,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline,
+		const zend_function *called_function)
+{
+	// TODO: file cache support
+
+	zend_begin_record_errors();
+	zend_op_array *op_array;
+
+	uint32_t orig_compiler_options = CG(compiler_options);
+
+	zend_try {
+		CG(compiler_options) |= ZEND_COMPILE_HANDLE_OP_ARRAY;
+		CG(compiler_options) |= ZEND_COMPILE_DELAYED_BINDING;
+		CG(compiler_options) |= ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION;
+		CG(compiler_options) |= ZEND_COMPILE_IGNORE_OTHER_FILES;
+		CG(compiler_options) |= ZEND_COMPILE_IGNORE_OBSERVER;
+#ifdef ZEND_WIN32
+		/* On Windows, don't compile with internal classes. Shm may be attached from different
+		 * processes with internal classes living in different addresses. */
+		CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES;
+#endif
+		if (ZCG(accel_directives).file_cache) {
+			CG(compiler_options) |= ZEND_COMPILE_WITH_FILE_CACHE;
+			/* Don't compile with internal classes for file cache, in case some extension is removed
+			 * later on. We cannot assume it is there in the future. */
+			CG(compiler_options) |= ZEND_COMPILE_IGNORE_INTERNAL_CLASSES;
+		}
+
+		op_array = zend_compile_ast(ast, ZEND_USER_FUNCTION, declaring_op_array->filename);
+
+		ZEND_ASSERT(op_array->num_dynamic_func_defs == 1);
+
+		CG(compiler_options) = orig_compiler_options;
+	} zend_catch {
+		op_array = NULL;
+		CG(compiler_options) = orig_compiler_options;
+		zend_bailout();
+	} zend_end_try();
+
+	// TODO: record errors in SHM
+	zend_emit_recorded_errors();
+	zend_free_recorded_errors();
+
+	if (!op_array) {
+		return NULL;
+	}
+
+	/* Cache op_array only if the declaring op_array and the called function
+	 * are cached */
+	if (!ZCG(accelerator_enabled)
+			|| declaring_op_array->refcount
+			|| (called_function->type == ZEND_USER_FUNCTION && called_function->op_array.refcount)) {
+		zend_op_array *closure = op_array->dynamic_func_defs[0];
+		GC_ADDREF(closure->function_name);
+		(*closure->refcount)++;
+		destroy_op_array(op_array);
+		efree(op_array);
+		return closure;
+	}
+
+	zend_persistent_script *new_persistent_script = create_persistent_script();
+	new_persistent_script->script.main_op_array = *op_array;
+	efree_size(op_array, sizeof(zend_op_array));
+
+	zend_string *key = zend_accel_pfa_key(declaring_opline, called_function);
+
+	new_persistent_script->script.filename = key;
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+	SHM_UNPROTECT();
+
+	bool from_shared_memory;
+	/* See GH-17246: we disable GC so that user code cannot be executed during the optimizer run. */
+	bool orig_gc_state = gc_enable(false);
+	new_persistent_script = cache_script_in_shared_memory(new_persistent_script, NULL, &from_shared_memory);
+	gc_enable(orig_gc_state);
+
+	SHM_PROTECT();
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+
+	return new_persistent_script->script.main_op_array.dynamic_func_defs[0];
+}
+
 /* zend_compile() replacement */
 zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 {
diff --git a/ext/opcache/ZendAccelerator.h b/ext/opcache/ZendAccelerator.h
index 524a6f5e12139..5a4bccf650e2b 100644
--- a/ext/opcache/ZendAccelerator.h
+++ b/ext/opcache/ZendAccelerator.h
@@ -336,6 +336,15 @@ zend_string* ZEND_FASTCALL accel_new_interned_string(zend_string *str);
 
 uint32_t zend_accel_get_class_name_map_ptr(zend_string *type_name);
 
+zend_op_array *zend_accel_pfa_cache_get(const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline,
+		const zend_function *called_function);
+
+zend_op_array *zend_accel_compile_pfa(zend_ast *ast,
+		const zend_op_array *declaring_op_array,
+		const zend_op *declaring_opline,
+		const zend_function *called_function);
+
 END_EXTERN_C()
 
 /* memory write protection */
diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
index 30f49fb73f676..e6142732fedb4 100644
--- a/ext/opcache/jit/zend_jit.c
+++ b/ext/opcache/jit/zend_jit.c
@@ -302,6 +302,7 @@ static int zend_jit_needs_call_chain(zend_call_info *call_info, uint32_t b, cons
 					case ZEND_DO_FCALL_BY_NAME:
 					case ZEND_DO_FCALL:
 					case ZEND_CALLABLE_CONVERT:
+					case ZEND_CALLABLE_CONVERT_PARTIAL:
 						return 0;
 					case ZEND_SEND_VAL:
 					case ZEND_SEND_VAR:
@@ -387,6 +388,7 @@ static int zend_jit_needs_call_chain(zend_call_info *call_info, uint32_t b, cons
 				case ZEND_DO_FCALL_BY_NAME:
 				case ZEND_DO_FCALL:
 				case ZEND_CALLABLE_CONVERT:
+				case ZEND_CALLABLE_CONVERT_PARTIAL:
 					end = opline;
 					if (end - op_array->opcodes >= ssa->cfg.blocks[b].start + ssa->cfg.blocks[b].len) {
 						/* INIT_FCALL and DO_FCALL in different BasicBlocks */
@@ -866,6 +868,7 @@ static bool zend_jit_dec_call_level(uint8_t opcode)
 		case ZEND_DO_UCALL:
 		case ZEND_DO_FCALL_BY_NAME:
 		case ZEND_CALLABLE_CONVERT:
+		case ZEND_CALLABLE_CONVERT_PARTIAL:
 			return true;
 		default:
 			return false;
diff --git a/ext/opcache/jit/zend_jit_vm_helpers.c b/ext/opcache/jit/zend_jit_vm_helpers.c
index cb896c0cd8c6f..49b4551c0a623 100644
--- a/ext/opcache/jit/zend_jit_vm_helpers.c
+++ b/ext/opcache/jit/zend_jit_vm_helpers.c
@@ -1059,7 +1059,8 @@ zend_jit_trace_stop ZEND_FASTCALL zend_jit_trace_execute(zend_execute_data  *ex,
 				TRACE_RECORD(ZEND_JIT_TRACE_DO_ICALL, 0, func);
 			}
 		} else if (opline->opcode == ZEND_INCLUDE_OR_EVAL
-				|| opline->opcode == ZEND_CALLABLE_CONVERT) {
+				|| opline->opcode == ZEND_CALLABLE_CONVERT
+				|| opline->opcode == ZEND_CALLABLE_CONVERT_PARTIAL) {
 			/* TODO: Support tracing JIT for ZEND_CALLABLE_CONVERT. */
 			stop = ZEND_JIT_TRACE_STOP_INTERPRETER;
 			break;
diff --git a/ext/opcache/zend_file_cache.c b/ext/opcache/zend_file_cache.c
index 4ec285be84348..53f18cacd1506 100644
--- a/ext/opcache/zend_file_cache.c
+++ b/ext/opcache/zend_file_cache.c
@@ -387,6 +387,7 @@ static void zend_file_cache_serialize_ast(zend_ast                 *ast,
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		zend_ast_fcc *fcc = (zend_ast_fcc*)ast;
 		ZEND_MAP_PTR_INIT(fcc->fptr, NULL);
+		zend_file_cache_serialize_ast(fcc->args, script, info, buf);
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
 		ZEND_UNREACHABLE();
@@ -1288,6 +1289,7 @@ static void zend_file_cache_unserialize_ast(zend_ast                *ast,
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		zend_ast_fcc *fcc = (zend_ast_fcc*)ast;
 		ZEND_MAP_PTR_NEW(fcc->fptr);
+		zend_file_cache_unserialize_ast(fcc->args, script, buf);
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
 		ZEND_UNREACHABLE();
@@ -2093,7 +2095,7 @@ void zend_file_cache_invalidate(zend_string *full_path)
 	if (ZCG(accel_directives).file_cache_read_only) {
 		return;
 	}
-	
+
 	char *filename;
 
 	filename = zend_file_cache_get_bin_file_path(full_path);
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 38e58d5a16632..840d8e864b289 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -197,6 +197,7 @@ static zend_ast *zend_persist_ast(zend_ast *ast)
 		node = (zend_ast *) copy;
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
 		zend_ast_fcc *copy = zend_shared_memdup(ast, sizeof(zend_ast_fcc));
+		copy->args = zend_persist_ast(copy->args);
 		node = (zend_ast *) copy;
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index 106a69f5dd383..b041c5bbdfe4c 100644
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -92,7 +92,9 @@ static void zend_persist_ast_calc(zend_ast *ast)
 		ZVAL_PTR(&z, zend_ast_get_op_array(ast)->op_array);
 		zend_persist_op_array_calc(&z);
 	} else if (ast->kind == ZEND_AST_CALLABLE_CONVERT) {
+		zend_ast_fcc *fcc_ast = (zend_ast_fcc*)ast;
 		ADD_SIZE(sizeof(zend_ast_fcc));
+		zend_persist_ast_calc(fcc_ast->args);
 	} else if (zend_ast_is_decl(ast)) {
 		/* Not implemented. */
 		ZEND_UNREACHABLE();
diff --git a/win32/build/config.w32 b/win32/build/config.w32
index 403f0aa6efbfe..1efdc57bca4da 100644
--- a/win32/build/config.w32
+++ b/win32/build/config.w32
@@ -241,7 +241,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
 	zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \
 	zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c zend_system_id.c \
 	zend_enum.c zend_fibers.c zend_atomic.c zend_hrtime.c zend_frameless_function.c zend_property_hooks.c \
-	zend_lazy_objects.c");
+	zend_lazy_objects.c zend_partial.c");
 ADD_SOURCES("Zend\\Optimizer", "zend_optimizer.c pass1.c pass3.c optimize_func_calls.c block_pass.c optimize_temp_vars_5.c nop_removal.c compact_literals.c zend_cfg.c zend_dfg.c dfa_pass.c zend_ssa.c zend_inference.c zend_func_info.c zend_call_graph.c zend_dump.c escape_analysis.c compact_vars.c dce.c sccp.c scdf.c");
 
 var PHP_ASSEMBLER = PATH_PROG({