diff --git a/Zend/tests/context_managers/basic.phpt b/Zend/tests/context_managers/basic.phpt
new file mode 100644
index 0000000000000..8db203242d69d
--- /dev/null
+++ b/Zend/tests/context_managers/basic.phpt
@@ -0,0 +1,22 @@
+--TEST--
+using() calls enter and exit
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager() as $value) {
+    echo "In using() block\n";
+    var_dump($value);
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECTF--
+Manager::enterContext()
+In using() block
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(null)
+After using() block
diff --git a/Zend/tests/context_managers/basic_manager.inc b/Zend/tests/context_managers/basic_manager.inc
new file mode 100644
index 0000000000000..fdf4a694a1f53
--- /dev/null
+++ b/Zend/tests/context_managers/basic_manager.inc
@@ -0,0 +1,22 @@
+<?php
+
+class Manager implements ContextManager
+{
+    public function __construct(private bool $rethrow = true)
+    {
+    }
+
+    public function enterContext(): mixed
+    {
+        echo __METHOD__, "()\n";
+        return new stdClass;
+    }
+
+    public function exitContext(?\Throwable $e = null): ?bool
+    {
+        echo __METHOD__, "(", ($e ? get_class($e) . '(' . $e->getMessage() . ')' : 'null'), ")\n";
+        return !$this->rethrow;
+    }
+}
+
+?>
diff --git a/Zend/tests/context_managers/break_jumps_out_of_the_block_with_success.phpt b/Zend/tests/context_managers/break_jumps_out_of_the_block_with_success.phpt
new file mode 100644
index 0000000000000..c064c0e648de1
--- /dev/null
+++ b/Zend/tests/context_managers/break_jumps_out_of_the_block_with_success.phpt
@@ -0,0 +1,22 @@
+--TEST--
+'break' in using() jumps out of the block, considered a success
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager() as $value) {
+    echo "In using() block\n";
+    break;
+    echo "Not executed\n";
+    var_dump($value);
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECT--
+Manager::enterContext()
+In using() block
+Manager::exitContext(null)
+After using() block
diff --git a/Zend/tests/context_managers/continue_jumps_out_of_the_block_warning.phpt b/Zend/tests/context_managers/continue_jumps_out_of_the_block_warning.phpt
new file mode 100644
index 0000000000000..2edb1927d7d2d
--- /dev/null
+++ b/Zend/tests/context_managers/continue_jumps_out_of_the_block_warning.phpt
@@ -0,0 +1,23 @@
+--TEST--
+'continue' in using() jumps out of the block, considered a success, warns like 'switch'
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager() as $value) {
+    echo "In using() block\n";
+    continue;
+    echo "Not executed\n";
+    var_dump($value);
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECTF--
+Warning: "continue" targeting using is equivalent to "break" in %s on line %d
+Manager::enterContext()
+In using() block
+Manager::exitContext(null)
+After using() block
diff --git a/Zend/tests/context_managers/exitContext_can_swallow_exception.phpt b/Zend/tests/context_managers/exitContext_can_swallow_exception.phpt
new file mode 100644
index 0000000000000..4345a59fc8299
--- /dev/null
+++ b/Zend/tests/context_managers/exitContext_can_swallow_exception.phpt
@@ -0,0 +1,23 @@
+--TEST--
+using() does not rethrow exception when exitContext() returns true
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager(false) as $value) {
+    echo "In using() block\n";
+    var_dump($value);
+    throw new Exception('exception in using block');
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECTF--
+Manager::enterContext()
+In using() block
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(Exception(exception in using block))
+After using() block
diff --git a/Zend/tests/context_managers/goto_jumps_out_of_the_block_with_success.phpt b/Zend/tests/context_managers/goto_jumps_out_of_the_block_with_success.phpt
new file mode 100644
index 0000000000000..28113f3492d9e
--- /dev/null
+++ b/Zend/tests/context_managers/goto_jumps_out_of_the_block_with_success.phpt
@@ -0,0 +1,23 @@
+--TEST--
+'goto' in using() jumps out of the block, considered a success
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager() as $value) {
+    echo "In using() block\n";
+    goto out;
+    echo "Not executed\n";
+    var_dump($value);
+}
+out:
+
+echo "After using() block\n";
+
+?>
+--EXPECT--
+Manager::enterContext()
+In using() block
+Manager::exitContext(null)
+After using() block
diff --git a/Zend/tests/context_managers/using_restores_cv_001.phpt b/Zend/tests/context_managers/using_restores_cv_001.phpt
new file mode 100644
index 0000000000000..be1ffdbdaa197
--- /dev/null
+++ b/Zend/tests/context_managers/using_restores_cv_001.phpt
@@ -0,0 +1,38 @@
+--TEST--
+using() restores CV
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+class A {}
+
+$value = new A;
+$value2 = $value;
+
+echo "# \$value before using():\n";
+var_dump($value);
+
+using (new Manager() as $value) {
+    echo "# \$value in using():\n";
+    var_dump($value);
+}
+
+echo "# \$value after using():\n";
+var_dump($value);
+var_dump($value === $value2);
+
+?>
+--EXPECTF--
+# $value before using():
+object(A)#%d (0) {
+}
+Manager::enterContext()
+# $value in using():
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(null)
+# $value after using():
+object(A)#%d (0) {
+}
+bool(true)
diff --git a/Zend/tests/context_managers/using_restores_cv_002.phpt b/Zend/tests/context_managers/using_restores_cv_002.phpt
new file mode 100644
index 0000000000000..4fb91662a0b56
--- /dev/null
+++ b/Zend/tests/context_managers/using_restores_cv_002.phpt
@@ -0,0 +1,24 @@
+--TEST--
+using() restores CV iff it was set
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager() as $value) {
+    var_dump($value);
+}
+
+echo "\$value is set after using():\n";
+var_dump(isset($value));
+var_dump(array_key_exists('value', get_defined_vars()));
+
+?>
+--EXPECTF--
+Manager::enterContext()
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(null)
+$value is set after using():
+bool(false)
+bool(false)
diff --git a/Zend/tests/context_managers/using_restores_cv_003.phpt b/Zend/tests/context_managers/using_restores_cv_003.phpt
new file mode 100644
index 0000000000000..7ded4377c68ac
--- /dev/null
+++ b/Zend/tests/context_managers/using_restores_cv_003.phpt
@@ -0,0 +1,44 @@
+--TEST--
+using() restores CV and preserves references
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+class A {}
+class B {}
+
+$value = new A;
+$value2 = &$value;
+
+echo "# \$value before using():\n";
+var_dump($value);
+
+using (new Manager() as $value) {
+    echo "# \$value in using():\n";
+    var_dump($value);
+    $value = null;
+}
+
+echo "# \$value after using():\n";
+var_dump($value);
+$value = new B;
+
+echo "# \$value2 references \$value:\n";
+var_dump($value2 === $value);
+
+?>
+--EXPECTF--
+# $value before using():
+object(A)#%d (0) {
+}
+Manager::enterContext()
+# $value in using():
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(null)
+# $value after using():
+object(A)#%d (0) {
+}
+# $value2 references $value:
+bool(true)
diff --git a/Zend/tests/context_managers/variable_is_optional.phpt b/Zend/tests/context_managers/variable_is_optional.phpt
new file mode 100644
index 0000000000000..b9a8265939bdf
--- /dev/null
+++ b/Zend/tests/context_managers/variable_is_optional.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Variable on the rhs of 'as' is optional
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+using (new Manager()) {
+    echo "In using() block\n";
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECT--
+Manager::enterContext()
+In using() block
+Manager::exitContext(null)
+After using() block
diff --git a/Zend/tests/context_managers/with_boxes_resources.phpt b/Zend/tests/context_managers/with_boxes_resources.phpt
new file mode 100644
index 0000000000000..fd124da4bea5c
--- /dev/null
+++ b/Zend/tests/context_managers/with_boxes_resources.phpt
@@ -0,0 +1,20 @@
+--TEST--
+using() boxes resources in ResourceContextManager
+--FILE--
+<?php
+
+$fd = fopen("php://memory", "r");
+using ($fd as $value) {
+    echo "In using() block\n";
+    var_dump($value);
+}
+
+echo "After using() block\n";
+var_dump($fd);
+
+?>
+--EXPECTF--
+In using() block
+resource(%d) of type (stream)
+After using() block
+resource(%d) of type (Unknown)
diff --git a/Zend/tests/context_managers/with_calls_exitContext_on_exception.phpt b/Zend/tests/context_managers/with_calls_exitContext_on_exception.phpt
new file mode 100644
index 0000000000000..211b145e4233d
--- /dev/null
+++ b/Zend/tests/context_managers/with_calls_exitContext_on_exception.phpt
@@ -0,0 +1,28 @@
+--TEST--
+using() calls exitContext($exception) on exception and re-throws by default
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+try {
+    using (new Manager() as $value) {
+        echo "In using() block\n";
+        var_dump($value);
+        throw new Exception('exception in using block');
+    }
+} catch (Exception $e) {
+    echo $e::class, ": ", $e->getMessage(), "\n";
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECTF--
+Manager::enterContext()
+In using() block
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(Exception(exception in using block))
+Exception: exception in using block
+After using() block
diff --git a/Zend/tests/context_managers/with_handles_throwable.phpt b/Zend/tests/context_managers/with_handles_throwable.phpt
new file mode 100644
index 0000000000000..e62e7a094fbc9
--- /dev/null
+++ b/Zend/tests/context_managers/with_handles_throwable.phpt
@@ -0,0 +1,28 @@
+--TEST--
+using() handles Throwable
+--FILE--
+<?php
+
+require 'basic_manager.inc';
+
+try {
+    using (new Manager() as $value) {
+        echo "In using() block\n";
+        var_dump($value);
+        throw new Error('error in using block');
+    }
+} catch (Error $e) {
+    echo $e::class, ": ", $e->getMessage(), "\n";
+}
+
+echo "After using() block\n";
+
+?>
+--EXPECTF--
+Manager::enterContext()
+In using() block
+object(stdClass)#%d (0) {
+}
+Manager::exitContext(Error(error in using block))
+Error: error in using block
+After using() block
diff --git a/Zend/tests/context_managers/with_keyword_is_semi_reserved.phpt b/Zend/tests/context_managers/with_keyword_is_semi_reserved.phpt
new file mode 100644
index 0000000000000..93c95df893037
--- /dev/null
+++ b/Zend/tests/context_managers/with_keyword_is_semi_reserved.phpt
@@ -0,0 +1,22 @@
+--TEST--
+'using' keyword is semi reserved
+--FILE--
+<?php
+
+class Test {
+    const WITH = 1;
+    public $using;
+    function using ($using) {}
+}
+
+$using = 1;
+
+// Not allowed:
+// function using() {}
+// class using {}
+// const WITH = 1;
+
+?>
+==DONE==
+--EXPECT--
+==DONE==
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index 9774cce39db2b..d8ae869f7dc7a 100644
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -400,6 +400,43 @@ 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_list_3(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3) {
+	zend_ast *ast;
+	zend_ast_list *list;
+	uint32_t lineno;
+
+	ast = zend_ast_alloc(zend_ast_list_size(4));
+	list = (zend_ast_list *) ast;
+	list->kind = kind;
+	list->attr = 0;
+	list->children = 3;
+	list->child[0] = child1;
+	list->child[1] = child2;
+	list->child[2] = child3;
+	if (child1) {
+		lineno = zend_ast_get_lineno(child1);
+		if (lineno > CG(zend_lineno)) {
+			lineno = CG(zend_lineno);
+		}
+	} else if (child2) {
+		lineno = zend_ast_get_lineno(child2);
+		if (lineno > CG(zend_lineno)) {
+			lineno = CG(zend_lineno);
+		}
+	} else if (child3) {
+		lineno = zend_ast_get_lineno(child3);
+		if (lineno > CG(zend_lineno)) {
+			lineno = CG(zend_lineno);
+		}
+	} else {
+		list->children = 0;
+		lineno = CG(zend_lineno);
+	}
+	list->lineno = lineno;
+
+	return ast;
+}
 #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;
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index fb48b187252b3..23006c6f6a073 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -154,6 +154,7 @@ enum _zend_ast_kind {
 	ZEND_AST_NAMED_ARG,
 	ZEND_AST_PARENT_PROPERTY_HOOK_CALL,
 	ZEND_AST_PIPE,
+	ZEND_AST_RESTORE_CV,
 
 	/* 3 child nodes */
 	ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,
@@ -166,6 +167,7 @@ enum _zend_ast_kind {
 	ZEND_AST_PROP_GROUP,
 	ZEND_AST_CONST_ELEM,
 	ZEND_AST_CLASS_CONST_GROUP,
+	ZEND_AST_USING,
 
 	// Pseudo node for initializing enums
 	ZEND_AST_CONST_ENUM_INIT,
@@ -306,6 +308,7 @@ static zend_always_inline zend_ast * zend_ast_create_ex_5(zend_ast_kind kind, ze
 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_list_3(zend_ast_kind kind, zend_ast *child1, zend_ast *child2, zend_ast *child3);
 
 # define zend_ast_create(...) \
 	ZEND_AST_SPEC_CALL(zend_ast_create, __VA_ARGS__)
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index eab2a03990112..8bba5081357e2 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -31,6 +31,7 @@
 #include "zend_generators.h"
 #include "zend_builtin_functions_arginfo.h"
 #include "zend_smart_str.h"
+#include "zend_context_managers.h"
 
 /* }}} */
 
@@ -39,6 +40,8 @@ ZEND_MINIT_FUNCTION(core) { /* {{{ */
 
 	zend_standard_class_def = register_class_stdClass();
 
+	ZEND_MINIT(context_managers)(INIT_FUNC_ARGS_PASSTHRU);
+
 	return SUCCESS;
 }
 /* }}} */
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index d61c2df0a3555..54d95b2fef358 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -38,6 +38,7 @@
 #include "zend_call_stack.h"
 #include "zend_frameless_function.h"
 #include "zend_property_hooks.h"
+#include "zend_builtin_functions.h"
 
 #define SET_NODE(target, src) do { \
 		target ## _type = (src)->op_type; \
@@ -101,6 +102,7 @@ static zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t
 static void zend_compile_expr(znode *result, zend_ast *ast);
 static void zend_compile_stmt(zend_ast *ast);
 static void zend_compile_assign(znode *result, zend_ast *ast);
+static void zend_compile_try(zend_ast *ast);
 
 #ifdef ZEND_CHECK_STACK_LIMIT
 zend_never_inline static void zend_stack_limit_error(void)
@@ -710,7 +712,7 @@ void zend_stop_lexing(void)
 }
 
 static inline void zend_begin_loop(
-		uint8_t free_opcode, const znode *loop_var, bool is_switch) /* {{{ */
+		uint8_t free_opcode, const znode *loop_var, zend_brk_cont_kind kind) /* {{{ */
 {
 	zend_brk_cont_element *brk_cont_element;
 	int parent = CG(context).current_brk_cont;
@@ -719,7 +721,7 @@ static inline void zend_begin_loop(
 	CG(context).current_brk_cont = CG(context).last_brk_cont;
 	brk_cont_element = get_next_brk_cont_element();
 	brk_cont_element->parent = parent;
-	brk_cont_element->is_switch = is_switch;
+	brk_cont_element->kind = kind;
 
 	if (loop_var && (loop_var->op_type & (IS_VAR|IS_TMP_VAR))) {
 		uint32_t start = get_next_op_number();
@@ -3539,6 +3541,16 @@ static void zend_compile_assign(znode *result, zend_ast *ast) /* {{{ */
 
 			zend_compile_list_assign(result, var_ast, &expr_node, var_ast->attr);
 			return;
+		case ZEND_AST_ZNODE:
+			var_node = *zend_ast_get_znode(var_ast);
+			zend_compile_expr(&expr_node, expr_ast);
+			if (expr_node.op_type == IS_CONST) {
+				opline = zend_emit_op(NULL, ZEND_QM_ASSIGN, &expr_node, NULL);
+			} else {
+				opline = zend_emit_op(NULL, ZEND_COPY_TMP, &expr_node, NULL);
+			}
+			SET_NODE(opline->result, &var_node);
+			break;
 		EMPTY_SWITCH_DEFAULT_CASE();
 	}
 }
@@ -5786,6 +5798,179 @@ static void zend_compile_void_cast(znode *result, zend_ast *ast)
 	}
 }
 
+static void zend_emit_copy_tmp(znode *result, znode *expr)
+{
+	if (expr->op_type == IS_VAR) {
+		zend_emit_op(result, ZEND_COPY_TMP, expr, NULL);
+	} else if (expr->op_type == IS_TMP_VAR) {
+		zend_emit_op_tmp(result, ZEND_COPY_TMP, expr, NULL);
+	} else {
+		if (expr->op_type == IS_CONST) {
+			Z_TRY_ADDREF(expr->u.constant);
+		}
+		*result = *expr;
+	}
+}
+
+static void zend_compile_using(zend_ast *ast)
+{
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast *var_ast = ast->child[1];
+	zend_ast *stmts_ast = ast->child[2];
+
+	znode tmp;
+
+	/* manager = (expr); */
+	znode manager;
+	zend_compile_expr(&manager, expr_ast);
+	if (manager.op_type == IS_CV) {
+		zend_emit_op_tmp(&manager, ZEND_QM_ASSIGN, &manager, NULL);
+	}
+
+	/* check type of manager; */
+	zend_emit_op(&manager, ZEND_INIT_USING, &manager, NULL);
+
+	/* $var = manager->enterContext() */
+	zend_emit_copy_tmp(&tmp, &manager);
+	zend_ast *enter_ast = zend_ast_create(ZEND_AST_METHOD_CALL,
+			zend_ast_create_znode(&tmp),
+			zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_ENTER_CONTEXT)),
+			zend_ast_create_list(0, ZEND_AST_ARG_LIST));
+	znode var_backup;
+	znode var_node;
+	if (var_ast) {
+		/* backup $var */
+		zend_compile_var(&var_node, var_ast, BP_VAR_IS, false);
+		zend_emit_op(&var_backup, ZEND_BACKUP_CV, &var_node, NULL);
+
+		/* assign $var */
+		zend_compile_stmt(zend_ast_create(ZEND_AST_UNSET, var_ast));
+		zend_compile_assign(&tmp, zend_ast_create(ZEND_AST_ASSIGN, var_ast, enter_ast));
+	} else {
+		zend_compile_method_call(&tmp, enter_ast, BP_VAR_R);
+	}
+	zend_do_free(&tmp);
+
+	/* closed = false;
+	 * try {
+	 *   stmts;
+	 * } catch (\Throwable e) {
+	 *   closed = true;
+	 *   if (manager->exitContext(e) !== true) {
+	 *     throw e;
+	 *   }
+	 * } finally {
+	 *   if (closed !== true) {
+	 *     manager->exitContext(null);
+	 *   }
+	 *   unset($var);
+	 * }
+	 */
+
+	zend_ast *exception_class_name = zend_ast_create_zval_from_str(zend_string_copy(zend_ce_throwable->name));
+	exception_class_name->attr = ZEND_NAME_FQ;
+
+	znode null_node;
+	null_node.op_type = IS_CONST;
+	ZVAL_NULL(&null_node.u.constant);
+
+	znode true_node;
+	true_node.op_type = IS_CONST;
+	ZVAL_TRUE(&true_node.u.constant);
+
+	znode false_node;
+	false_node.op_type = IS_CONST;
+	ZVAL_FALSE(&false_node.u.constant);
+
+	znode exception;
+	exception.op_type = IS_TMP_VAR;
+	exception.u.op.var = get_temporary_variable();
+
+	znode exception_copy;
+	exception_copy.op_type = IS_TMP_VAR;
+	exception_copy.u.op.var = get_temporary_variable();
+
+	znode closed;
+	zend_emit_op_tmp(&closed, ZEND_QM_ASSIGN, &false_node, NULL);
+
+	zend_begin_loop(ZEND_NOP, NULL, ZEND_BRK_CONT_USING);
+
+	zend_ast *catch_list = zend_ast_create_list(1, ZEND_AST_CATCH_LIST,
+			/* } catch (Exception exception) { */
+			zend_ast_create(ZEND_AST_CATCH,
+				zend_ast_create_list(1, ZEND_AST_NAME_LIST, exception_class_name),
+				zend_ast_create_znode(&exception),
+				zend_ast_create_list(3, ZEND_AST_STMT_LIST,
+					/* closed = true; */
+					zend_ast_create(ZEND_AST_ASSIGN,
+						zend_ast_create_znode(&closed),
+						zend_ast_create_znode(&true_node)),
+					/* exception_copy = exception; */
+					zend_ast_create(ZEND_AST_ASSIGN,
+						zend_ast_create_znode(&exception_copy),
+						zend_ast_create_znode(&exception)),
+					/* if (manager->exitContext(exception) !== true) { */
+					zend_ast_create_list(2, ZEND_AST_IF,
+						zend_ast_create(ZEND_AST_IF_ELEM,
+							zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL,
+								zend_ast_create(ZEND_AST_METHOD_CALL,
+									zend_ast_create_znode(&manager),
+									zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_EXIT_CONTEXT)),
+									zend_ast_create_list(1, ZEND_AST_ARG_LIST, zend_ast_create_znode(&exception))),
+								zend_ast_create_znode(&true_node)),
+							zend_ast_create_list(1, ZEND_AST_STMT_LIST,
+								/* throw exception_copy; */
+								zend_ast_create(ZEND_AST_THROW, zend_ast_create_znode(&exception_copy)))),
+						/* } else { */
+						zend_ast_create(ZEND_AST_IF_ELEM,
+							NULL,
+							/* free exception_copy */
+							zend_ast_create(ZEND_AST_CAST_VOID, zend_ast_create_znode(&exception_copy)))))));
+
+	zend_ast *finally_stmt = zend_ast_create_list(1, ZEND_AST_STMT_LIST,
+			/* if (closed !== true) { */
+			zend_ast_create_list(1, ZEND_AST_IF,
+				zend_ast_create(ZEND_AST_IF_ELEM,
+					zend_ast_create_binary_op(ZEND_IS_NOT_IDENTICAL,
+						zend_ast_create_znode(&closed),
+						zend_ast_create_znode(&true_node)),
+					/* manager->exitContext() */
+					zend_ast_create_list(1, ZEND_AST_STMT_LIST,
+						zend_ast_create(ZEND_AST_METHOD_CALL,
+							zend_ast_create_znode(&manager),
+							zend_ast_create_zval_from_str(ZSTR_KNOWN(ZEND_STR_EXIT_CONTEXT)),
+							zend_ast_create_list(0, ZEND_AST_ARG_LIST))))));
+
+	if (var_ast) {
+		/* unset($var) */
+		finally_stmt = zend_ast_list_add(finally_stmt,
+			zend_ast_create(ZEND_AST_UNSET, var_ast));
+		/* restore $var */
+		finally_stmt = zend_ast_list_add(finally_stmt,
+			zend_ast_create(ZEND_AST_RESTORE_CV, var_ast,
+				zend_ast_create_znode(&var_backup)));
+	}
+
+	zend_compile_try(zend_ast_create(ZEND_AST_TRY, stmts_ast, catch_list, finally_stmt));
+
+	zend_end_loop(get_next_op_number(), NULL);
+}
+
+static void zend_compile_restore_cv(zend_ast *ast)
+{
+	zend_ast *var_ast = ast->child[0];
+	zend_ast *backup_ast = ast->child[1];
+
+	znode var_node;
+	znode backup_node;
+
+	zend_compile_expr(&var_node, var_ast);
+	zend_compile_expr(&backup_node, backup_ast);
+
+	zend_op *opline = zend_emit_op(NULL, ZEND_RESTORE_CV, &backup_node, NULL);
+	SET_NODE(opline->result, &var_node);
+}
+
 static void zend_compile_echo(zend_ast *ast) /* {{{ */
 {
 	zend_op *opline;
@@ -5861,27 +6046,30 @@ static void zend_compile_break_continue(zend_ast *ast) /* {{{ */
 			ZEND_ASSERT(cur != -1);
 		}
 
-		if (CG(context).brk_cont_array[cur].is_switch) {
+		if (CG(context).brk_cont_array[cur].kind == ZEND_BRK_CONT_SWITCH
+				|| CG(context).brk_cont_array[cur].kind == ZEND_BRK_CONT_USING) {
+			const char *keyword = CG(context).brk_cont_array[cur].kind == ZEND_BRK_CONT_SWITCH
+				? "switch" : "using";
 			if (depth == 1) {
 				if (CG(context).brk_cont_array[cur].parent == -1) {
 					zend_error(E_WARNING,
-						"\"continue\" targeting switch is equivalent to \"break\"");
+						"\"continue\" targeting %s is equivalent to \"break\"", keyword);
 				} else {
 					zend_error(E_WARNING,
-						"\"continue\" targeting switch is equivalent to \"break\". " \
+						"\"continue\" targeting %s is equivalent to \"break\". " \
 						"Did you mean to use \"continue " ZEND_LONG_FMT "\"?",
-						depth + 1);
+						keyword, depth + 1);
 				}
 			} else {
 				if (CG(context).brk_cont_array[cur].parent == -1) {
 					zend_error(E_WARNING,
-						"\"continue " ZEND_LONG_FMT "\" targeting switch is equivalent to \"break " ZEND_LONG_FMT "\"",
-						depth, depth);
+						"\"continue " ZEND_LONG_FMT "\" targeting %s is equivalent to \"break " ZEND_LONG_FMT "\"",
+						depth, keyword, depth);
 				} else {
 					zend_error(E_WARNING,
-						"\"continue " ZEND_LONG_FMT "\" targeting switch is equivalent to \"break " ZEND_LONG_FMT "\". " \
+						"\"continue " ZEND_LONG_FMT "\" targeting %s is equivalent to \"break " ZEND_LONG_FMT "\". " \
 						"Did you mean to use \"continue " ZEND_LONG_FMT "\"?",
-						depth, depth, depth + 1);
+						depth, keyword, depth, depth + 1);
 				}
 			}
 		}
@@ -5999,7 +6187,7 @@ static void zend_compile_while(zend_ast *ast) /* {{{ */
 
 	opnum_jmp = zend_emit_jump(0);
 
-	zend_begin_loop(ZEND_NOP, NULL, false);
+	zend_begin_loop(ZEND_NOP, NULL, ZEND_BRK_CONT_DEFAULT);
 
 	opnum_start = get_next_op_number();
 	zend_compile_stmt(stmt_ast);
@@ -6022,7 +6210,7 @@ static void zend_compile_do_while(zend_ast *ast) /* {{{ */
 	znode cond_node;
 	uint32_t opnum_start, opnum_cond;
 
-	zend_begin_loop(ZEND_NOP, NULL, false);
+	zend_begin_loop(ZEND_NOP, NULL, ZEND_BRK_CONT_DEFAULT);
 
 	opnum_start = get_next_op_number();
 	zend_compile_stmt(stmt_ast);
@@ -6079,7 +6267,7 @@ static void zend_compile_for(zend_ast *ast) /* {{{ */
 
 	opnum_jmp = zend_emit_jump(0);
 
-	zend_begin_loop(ZEND_NOP, NULL, false);
+	zend_begin_loop(ZEND_NOP, NULL, ZEND_BRK_CONT_DEFAULT);
 
 	opnum_start = get_next_op_number();
 	zend_compile_stmt(stmt_ast);
@@ -6141,7 +6329,7 @@ static void zend_compile_foreach(zend_ast *ast) /* {{{ */
 	opnum_reset = get_next_op_number();
 	opline = zend_emit_op(&reset_node, by_ref ? ZEND_FE_RESET_RW : ZEND_FE_RESET_R, &expr_node, NULL);
 
-	zend_begin_loop(ZEND_FE_FREE, &reset_node, false);
+	zend_begin_loop(ZEND_FE_FREE, &reset_node, ZEND_BRK_CONT_DEFAULT);
 
 	opnum_fetch = get_next_op_number();
 	opline = zend_emit_op(NULL, by_ref ? ZEND_FE_FETCH_RW : ZEND_FE_FETCH_R, &reset_node, NULL);
@@ -6314,7 +6502,7 @@ static void zend_compile_switch(zend_ast *ast) /* {{{ */
 
 	zend_compile_expr(&expr_node, expr_ast);
 
-	zend_begin_loop(ZEND_FREE, &expr_node, true);
+	zend_begin_loop(ZEND_FREE, &expr_node, ZEND_BRK_CONT_SWITCH);
 
 	case_node.op_type = IS_TMP_VAR;
 	case_node.u.op.var = get_temporary_variable();
@@ -6797,7 +6985,7 @@ static void zend_compile_try(zend_ast *ast) /* {{{ */
 		zend_ast_list *classes = zend_ast_get_list(catch_ast->child[0]);
 		zend_ast *var_ast = catch_ast->child[1];
 		zend_ast *stmt_ast = catch_ast->child[2];
-		zend_string *var_name = var_ast ? zval_make_interned_string(zend_ast_get_zval(var_ast)) : NULL;
+		zend_string *var_name = var_ast && var_ast->kind == ZEND_AST_ZVAL ? zval_make_interned_string(zend_ast_get_zval(var_ast)) : NULL;
 		bool is_last_catch = (i + 1 == catches->children);
 
 		uint32_t *jmp_multicatch = safe_emalloc(sizeof(uint32_t), classes->children - 1, 0);
@@ -6829,8 +7017,18 @@ static void zend_compile_try(zend_ast *ast) /* {{{ */
 				zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign $this");
 			}
 
-			opline->result_type = var_name ? IS_CV : IS_UNUSED;
-			opline->result.var = var_name ? lookup_cv(var_name) : -1;
+			if (var_name) {
+				opline->result_type = var_name ? IS_CV : IS_UNUSED;
+				opline->result.var = var_name ? lookup_cv(var_name) : -1;
+			} else if (var_ast && var_ast->kind == ZEND_AST_ZNODE) {
+				znode *node = zend_ast_get_znode(var_ast);
+				ZEND_ASSERT(node->op_type == IS_TMP_VAR);
+				opline->result_type = IS_TMP_VAR;
+				opline->result = node->u.op;
+			} else {
+				opline->result_type = IS_UNUSED;
+				opline->result.var = -1;
+			}
 
 			if (is_last_catch && is_last_class) {
 				opline->extended_value |= ZEND_LAST_CATCH;
@@ -11805,6 +12003,12 @@ static void zend_compile_stmt(zend_ast *ast) /* {{{ */
 		case ZEND_AST_CAST_VOID:
 			zend_compile_void_cast(NULL, ast);
 			break;
+		case ZEND_AST_USING:
+			zend_compile_using(ast);
+			break;
+		case ZEND_AST_RESTORE_CV:
+			zend_compile_restore_cv(ast);
+			break;
 		default:
 		{
 			znode result;
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 8321e4a03c1e3..c906a502b6fab 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -156,13 +156,18 @@ struct _zend_op {
 #endif
 };
 
+typedef enum _zend_brk_cont_kind {
+	ZEND_BRK_CONT_DEFAULT,
+	ZEND_BRK_CONT_SWITCH,
+	ZEND_BRK_CONT_USING,
+} zend_brk_cont_kind;
 
 typedef struct _zend_brk_cont_element {
 	int start;
 	int cont;
 	int brk;
 	int parent;
-	bool is_switch;
+	zend_brk_cont_kind kind;
 } zend_brk_cont_element;
 
 typedef struct _zend_label {
diff --git a/Zend/zend_context_managers.c b/Zend/zend_context_managers.c
new file mode 100644
index 0000000000000..017d7a5921c4b
--- /dev/null
+++ b/Zend/zend_context_managers.c
@@ -0,0 +1,100 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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_list.h"
+#include "zend_API.h"
+#include "zend_exceptions.h"
+#include "zend_context_managers_arginfo.h"
+
+ZEND_API zend_class_entry *zend_ce_context_manager = NULL;
+ZEND_API zend_class_entry *zend_ce_resource_context_manager = NULL;
+
+ZEND_MINIT_FUNCTION(context_managers)
+{
+	zend_ce_context_manager = register_class_ContextManager();
+	zend_ce_resource_context_manager = register_class_ResourceContextManager(zend_ce_context_manager);
+
+	return SUCCESS;
+}
+
+void zend_resource_context_manager_init(zend_object *obj, zend_resource *res)
+{
+	zval zres;
+	ZVAL_RES(&zres, res);
+
+	// TODO: reuse zend_update_property_num_checked() or similar
+	zend_update_property(obj->ce, obj, "resource", strlen("resource"), &zres);
+}
+
+ZEND_METHOD(ResourceContextManager, __construct)
+{
+	zval *zres;
+	zend_object *this = Z_OBJ_P(getThis());
+
+	ZEND_PARSE_PARAMETERS_START(1, 1);
+		Z_PARAM_RESOURCE(zres);
+	ZEND_PARSE_PARAMETERS_END();
+
+	zend_resource_context_manager_init(this, Z_RES_P(zres));
+}
+
+ZEND_METHOD(ResourceContextManager, enterContext)
+{
+	zend_object *this = Z_OBJ_P(getThis());
+
+	ZEND_PARSE_PARAMETERS_NONE();
+
+	zval rv;
+	zval *zres = zend_read_property(this->ce, this, "resource", strlen("resource"), false, &rv);
+
+	if (Z_TYPE_P(zres) != IS_RESOURCE) {
+		zend_throw_error(NULL, "%s object is not initialized", ZSTR_VAL(this->ce->name));
+		RETURN_THROWS();
+	}
+
+	RETURN_COPY_DEREF(zres);
+}
+
+ZEND_METHOD(ResourceContextManager, exitContext)
+{
+	zend_object *this = Z_OBJ_P(getThis());
+	zend_object *exception;
+
+	ZEND_PARSE_PARAMETERS_START(0, 1);
+		Z_PARAM_OPTIONAL
+		Z_PARAM_OBJ_OF_CLASS_OR_NULL(exception, zend_ce_throwable);
+	ZEND_PARSE_PARAMETERS_END();
+
+	zval rv;
+	zval *zres = zend_read_property(this->ce, this, "resource", strlen("resource"), false, &rv);
+
+	if (Z_TYPE_P(zres) != IS_RESOURCE) {
+		zend_throw_error(NULL, "%s object is not initialized", ZSTR_VAL(this->ce->name));
+		RETURN_THROWS();
+	}
+
+	zend_resource *res = Z_RES_P(zres);
+
+	if (res->type == -1) {
+		return;
+	}
+
+	zend_resource_dtor(res);
+
+	/* Do not swallow exception */
+	RETURN_FALSE;
+}
diff --git a/Zend/zend_context_managers.h b/Zend/zend_context_managers.h
new file mode 100644
index 0000000000000..fd27e8a727c1c
--- /dev/null
+++ b/Zend/zend_context_managers.h
@@ -0,0 +1,29 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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.              |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_CONTEXT_MANAGERS_H
+#define ZEND_CONTEXT_MANAGERS_H
+
+#include "zend_API.h"
+
+extern ZEND_API zend_class_entry *zend_ce_context_manager;
+extern ZEND_API zend_class_entry *zend_ce_resource_context_manager;
+
+ZEND_MINIT_FUNCTION(context_managers);
+
+void zend_resource_context_manager_init(zend_object *obj, zend_resource *res);
+
+#endif /* ZEND_CONTEXT_MANAGERS_H */
diff --git a/Zend/zend_context_managers.stub.php b/Zend/zend_context_managers.stub.php
new file mode 100644
index 0000000000000..a9d6e491cb49e
--- /dev/null
+++ b/Zend/zend_context_managers.stub.php
@@ -0,0 +1,21 @@
+<?php
+
+/** @generate-class-entries */
+
+interface ContextManager
+{
+    public function enterContext(): mixed;
+
+    public function exitContext(?\Throwable $e = null): ?bool;
+}
+
+final class ResourceContextManager implements ContextManager
+{
+    private readonly mixed $resource;
+
+    public function __construct(mixed $resource) {}
+
+    public function enterContext(): mixed {}
+
+    public function exitContext(?\Throwable $e = null): ?bool {}
+}
diff --git a/Zend/zend_context_managers_arginfo.h b/Zend/zend_context_managers_arginfo.h
new file mode 100644
index 0000000000000..f62983eb10390
--- /dev/null
+++ b/Zend/zend_context_managers_arginfo.h
@@ -0,0 +1,59 @@
+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 66bb22256116838bff490d86f41a65b5aeb5dd14 */
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ContextManager_enterContext, 0, 0, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ContextManager_exitContext, 0, 0, _IS_BOOL, 1)
+	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, e, Throwable, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ResourceContextManager___construct, 0, 0, 1)
+	ZEND_ARG_TYPE_INFO(0, resource, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_ResourceContextManager_enterContext arginfo_class_ContextManager_enterContext
+
+#define arginfo_class_ResourceContextManager_exitContext arginfo_class_ContextManager_exitContext
+
+ZEND_METHOD(ResourceContextManager, __construct);
+ZEND_METHOD(ResourceContextManager, enterContext);
+ZEND_METHOD(ResourceContextManager, exitContext);
+
+static const zend_function_entry class_ContextManager_methods[] = {
+	ZEND_RAW_FENTRY("enterContext", NULL, arginfo_class_ContextManager_enterContext, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_RAW_FENTRY("exitContext", NULL, arginfo_class_ContextManager_exitContext, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT, NULL, NULL)
+	ZEND_FE_END
+};
+
+static const zend_function_entry class_ResourceContextManager_methods[] = {
+	ZEND_ME(ResourceContextManager, __construct, arginfo_class_ResourceContextManager___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(ResourceContextManager, enterContext, arginfo_class_ResourceContextManager_enterContext, ZEND_ACC_PUBLIC)
+	ZEND_ME(ResourceContextManager, exitContext, arginfo_class_ResourceContextManager_exitContext, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_ContextManager(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "ContextManager", class_ContextManager_methods);
+	class_entry = zend_register_internal_interface(&ce);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_ResourceContextManager(zend_class_entry *class_entry_ContextManager)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "ResourceContextManager", class_ResourceContextManager_methods);
+	class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL);
+	zend_class_implements(class_entry, 1, class_entry_ContextManager);
+
+	zval property_resource_default_value;
+	ZVAL_UNDEF(&property_resource_default_value);
+	zend_declare_typed_property(class_entry, ZSTR_KNOWN(ZEND_STR_RESOURCE), &property_resource_default_value, ZEND_ACC_PRIVATE|ZEND_ACC_READONLY, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ANY));
+
+	return class_entry;
+}
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index c8863a4b27ad5..8d98494f09e18 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_context_managers.h"
 
 /* Virtual current working directory support */
 #include "zend_virtual_cwd.h"
@@ -3916,6 +3917,26 @@ ZEND_API ZEND_COLD void zend_throw_conflicting_coercion_error(const zend_propert
 	zend_string_release(type2_str);
 }
 
+ZEND_API ZEND_COLD void zend_throw_invalid_context_manager_error(zval *op1 OPLINE_DC EXECUTE_DATA_DC)
+{
+	execute_data->opline = opline;
+
+	const zend_arg_info arg_info = {
+		.type = ZEND_TYPE_INIT_CLASS(zend_ce_context_manager->name, 0, 0),
+	};
+	const char *fname;
+	const char *fsep;
+	const char *fclass;
+	zend_string *need_msg;
+	const char *given_kind;
+
+	zend_verify_type_error_common(
+		EX(func), &arg_info, op1, &fname, &fsep, &fclass, &need_msg, &given_kind);
+
+	zend_throw_error(NULL, "with() expression must be of type %s, %s given",
+			ZSTR_VAL(need_msg), given_kind);
+}
+
 /* 1: valid, 0: invalid, -1: may be valid after type coercion */
 static zend_always_inline int i_zend_verify_type_assignable_zval(
 		const zend_property_info *info, const zval *zv, bool strict) {
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index e4d61006fe12f..88f7e2c674ebd 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -183,6 +183,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token <ident> T_FUNC_C          "'__FUNCTION__'"
 %token <ident> T_PROPERTY_C      "'__PROPERTY__'"
 %token <ident> T_NS_C            "'__NAMESPACE__'"
+%token <ident> T_USING           "'using'"
 
 %token END 0 "end of file"
 %token T_ATTRIBUTE    "'#['"
@@ -271,7 +272,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> encaps_var encaps_var_offset isset_variables
 %type <ast> top_statement_list use_declarations const_list inner_statement_list if_stmt
 %type <ast> alt_if_stmt for_cond_exprs for_exprs switch_case_list global_var_list static_var_list
-%type <ast> echo_expr_list unset_variables catch_name_list catch_list optional_variable parameter_list class_statement_list
+%type <ast> echo_expr_list unset_variables catch_name_list catch_list optional_variable optional_using_as_variable parameter_list class_statement_list
 %type <ast> implements_list case_list if_stmt_without_else
 %type <ast> non_empty_parameter_list argument_list non_empty_argument_list property_list
 %type <ast> class_const_list class_const_decl class_name_list trait_adaptations method_body non_empty_for_exprs
@@ -311,7 +312,7 @@ reserved_non_modifiers:
 	| T_THROW | T_USE | T_INSTEADOF | T_GLOBAL | T_VAR | T_UNSET | T_ISSET | T_EMPTY | T_CONTINUE | T_GOTO
 	| T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT | T_BREAK
 	| T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS
-	| T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN | T_MATCH | T_ENUM
+	| T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN | T_MATCH | T_ENUM | T_USING
 	| T_PROPERTY_C
 ;
 
@@ -542,6 +543,13 @@ statement:
 	|	T_GOTO T_STRING ';' { $$ = zend_ast_create(ZEND_AST_GOTO, $2); }
 	|	T_STRING ':' { $$ = zend_ast_create(ZEND_AST_LABEL, $1); }
 	|	T_VOID_CAST expr ';' { $$ = zend_ast_create(ZEND_AST_CAST_VOID, $2); }
+	|	T_USING '(' expr optional_using_as_variable ')' '{' inner_statement_list '}'
+			{ $$ = zend_ast_create(ZEND_AST_USING, $3, $4, $7); }
+;
+
+optional_using_as_variable:
+		%empty          { $$ = NULL; }
+	|   T_AS T_VARIABLE { $$ = zend_ast_create(ZEND_AST_VAR, $2); }
 ;
 
 catch_list:
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 3ecb2f8d0ee45..bc61cdf8d295d 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -1634,6 +1634,10 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN_WITH_IDENT(T_VAR);
 }
 
+<ST_IN_SCRIPTING>"using" {
+	RETURN_TOKEN_WITH_IDENT(T_USING);
+}
+
 <ST_IN_SCRIPTING>"("{TABS_AND_SPACES}("int"){TABS_AND_SPACES}")" {
 	RETURN_TOKEN(T_INT_CAST);
 }
diff --git a/Zend/zend_list.c b/Zend/zend_list.c
index 5add19256a691..ab4ff66d5cbe0 100644
--- a/Zend/zend_list.c
+++ b/Zend/zend_list.c
@@ -58,7 +58,7 @@ ZEND_API void ZEND_FASTCALL zend_list_free(zend_resource *res)
 	zend_hash_index_del(&EG(regular_list), res->handle);
 }
 
-static void zend_resource_dtor(zend_resource *res)
+ZEND_API void ZEND_FASTCALL zend_resource_dtor(zend_resource *res)
 {
 	zend_rsrc_list_dtors_entry *ld;
 	zend_resource r = *res;
diff --git a/Zend/zend_list.h b/Zend/zend_list.h
index 55ccf78dca106..5f7fc690d465b 100644
--- a/Zend/zend_list.h
+++ b/Zend/zend_list.h
@@ -56,6 +56,7 @@ ZEND_API zval* ZEND_FASTCALL zend_list_insert(void *ptr, int type);
 ZEND_API void ZEND_FASTCALL zend_list_free(zend_resource *res);
 ZEND_API zend_result ZEND_FASTCALL zend_list_delete(zend_resource *res);
 ZEND_API void ZEND_FASTCALL zend_list_close(zend_resource *res);
+ZEND_API void ZEND_FASTCALL zend_resource_dtor(zend_resource *res);
 
 ZEND_API zend_resource *zend_register_resource(void *rsrc_pointer, int rsrc_type);
 ZEND_API void *zend_fetch_resource(zend_resource *res, const char *resource_type_name, int resource_type);
diff --git a/Zend/zend_string.h b/Zend/zend_string.h
index fc7705ff78650..f94ea99a7e0ef 100644
--- a/Zend/zend_string.h
+++ b/Zend/zend_string.h
@@ -630,6 +630,8 @@ EMPTY_SWITCH_DEFAULT_CASE()
 	_(ZEND_STR_AUTOGLOBAL_ENV,         "_ENV") \
 	_(ZEND_STR_AUTOGLOBAL_REQUEST,     "_REQUEST") \
 	_(ZEND_STR_COUNT,                  "count") \
+	_(ZEND_STR_ENTER_CONTEXT,          "enterContext") \
+	_(ZEND_STR_EXIT_CONTEXT,           "exitContext") \
 	_(ZEND_STR_SENSITIVEPARAMETER,     "SensitiveParameter") \
 	_(ZEND_STR_CONST_EXPR_PLACEHOLDER, "[constant expression]") \
 	_(ZEND_STR_DEPRECATED_CAPITALIZED, "Deprecated") \
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 3c3065e156871..6460bc8a397d6 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -4844,12 +4844,17 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, JMP_ADDR, LAST_CATCH|CACHE_SLOT)
 	exception = EG(exception);
 	EG(exception) = NULL;
 	if (RETURN_VALUE_USED(opline)) {
-		/* Always perform a strict assignment. There is a reasonable expectation that if you
-		 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
-		 * we should not permit coercion to string here. */
-		zval tmp;
-		ZVAL_OBJ(&tmp, exception);
-		zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		if (opline->result_type == IS_CV) {
+			/* Always perform a strict assignment. There is a reasonable expectation that if you
+			 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
+			 * we should not permit coercion to string here. */
+			zval tmp;
+			ZVAL_OBJ(&tmp, exception);
+			zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		} else {
+			ZEND_ASSERT(opline->result_type == IS_TMP_VAR);
+			ZVAL_OBJ(EX_VAR(opline->result.var), exception);
+		}
 	} else {
 		OBJ_RELEASE(exception);
 	}
@@ -9947,6 +9952,57 @@ ZEND_VM_HANDLER(209, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL, CONST, UNUSED|NUM, NUM
 	ZEND_VM_NEXT_OPCODE();
 }
 
+ZEND_VM_HANDLER(211, ZEND_INIT_USING, CONST|TMP|VAR|CV, UNUSED)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			ZEND_VM_C_GOTO(type_error);
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		ZEND_VM_C_GOTO(type_error);
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+ZEND_VM_C_LABEL(type_error):
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+	FREE_OP1();
+	HANDLE_EXCEPTION();
+}
+
+ZEND_VM_HANDLER(212, ZEND_BACKUP_CV, CV, UNUSED)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = GET_OP1_ZVAL_PTR(BP_VAR_IS);
+	ZVAL_COPY(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
+ZEND_VM_HANDLER(213, ZEND_RESTORE_CV, VAR, UNUSED)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = GET_OP1_ZVAL_PTR(BP_VAR_IS);
+	ZVAL_COPY_VALUE(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
 ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_JMP, (OP_JMP_ADDR(op, op->op1) > op), ZEND_JMP_FORWARD, JMP_ADDR, ANY)
 {
 	USE_OPLINE
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 50870ce463de3..ae1ca5a760d1b 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -5182,12 +5182,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CATCH_SPEC_CO
 	exception = EG(exception);
 	EG(exception) = NULL;
 	if (RETURN_VALUE_USED(opline)) {
-		/* Always perform a strict assignment. There is a reasonable expectation that if you
-		 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
-		 * we should not permit coercion to string here. */
-		zval tmp;
-		ZVAL_OBJ(&tmp, exception);
-		zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		if (opline->result_type == IS_CV) {
+			/* Always perform a strict assignment. There is a reasonable expectation that if you
+			 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
+			 * we should not permit coercion to string here. */
+			zval tmp;
+			ZVAL_OBJ(&tmp, exception);
+			zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		} else {
+			ZEND_ASSERT(opline->result_type == IS_TMP_VAR);
+			ZVAL_OBJ(EX_VAR(opline->result.var), exception);
+		}
 	} else {
 		OBJ_RELEASE(exception);
 	}
@@ -11891,6 +11896,37 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_PARENT_P
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USING_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = RT_CONSTANT(opline, opline->op1);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+
+	HANDLE_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -22380,6 +22416,37 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USING_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	HANDLE_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -31435,6 +31502,47 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USING_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	HANDLE_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RESTORE_CV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+	ZVAL_COPY_VALUE(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -52564,6 +52672,47 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USING_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+
+	HANDLE_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BACKUP_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+	ZVAL_COPY(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -60626,12 +60775,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CATCH_SPEC_CONST_T
 	exception = EG(exception);
 	EG(exception) = NULL;
 	if (RETURN_VALUE_USED(opline)) {
-		/* Always perform a strict assignment. There is a reasonable expectation that if you
-		 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
-		 * we should not permit coercion to string here. */
-		zval tmp;
-		ZVAL_OBJ(&tmp, exception);
-		zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		if (opline->result_type == IS_CV) {
+			/* Always perform a strict assignment. There is a reasonable expectation that if you
+			 * write "catch (Exception $e)" then $e will actually be instanceof Exception. As such,
+			 * we should not permit coercion to string here. */
+			zval tmp;
+			ZVAL_OBJ(&tmp, exception);
+			zend_assign_to_variable(EX_VAR(opline->result.var), &tmp, IS_TMP_VAR, /* strict */ 1);
+		} else {
+			ZEND_ASSERT(opline->result_type == IS_TMP_VAR);
+			ZVAL_OBJ(EX_VAR(opline->result.var), exception);
+		}
 	} else {
 		OBJ_RELEASE(exception);
 	}
@@ -67233,6 +67387,37 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_PARENT_PROPER
 	ZEND_VM_NEXT_OPCODE();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USING_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = RT_CONSTANT(opline, opline->op1);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+
+	HANDLE_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CONST_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -77622,6 +77807,37 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_TMP_
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USING_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	HANDLE_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -86677,6 +86893,47 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_VAR_
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USING_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	HANDLE_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RESTORE_CV_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+	ZVAL_COPY_VALUE(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -107704,6 +107961,47 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_CV_U
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USING_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval obj;
+	zval *op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+
+	if (EXPECTED(Z_TYPE_P(op1) == IS_OBJECT)) {
+		if (UNEXPECTED(!instanceof_function_slow(Z_OBJCE_P(op1), zend_ce_context_manager))) {
+			goto type_error;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_RESOURCE)) {
+		object_init_ex(&obj, zend_ce_resource_context_manager);
+		zend_resource_context_manager_init(Z_OBJ(obj), Z_RES_P(op1));
+		op1 = &obj;
+	} else {
+		goto type_error;
+	}
+
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), op1);
+	ZEND_VM_NEXT_OPCODE();
+
+type_error:
+	SAVE_OPLINE();
+
+	zend_throw_invalid_context_manager_error(op1 OPLINE_CC EXECUTE_DATA_CC);
+
+
+	HANDLE_EXCEPTION();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BACKUP_CV_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE;
+
+	zval *var = EX_VAR(opline->result.var);
+	zval *value = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC);
+	ZVAL_COPY(var, value);
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -114809,6 +115107,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_INIT_USING_SPEC_CONST_UNUSED_LABEL,
+			(void*)&&ZEND_INIT_USING_SPEC_TMP_UNUSED_LABEL,
+			(void*)&&ZEND_INIT_USING_SPEC_VAR_UNUSED_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
+			(void*)&&ZEND_INIT_USING_SPEC_CV_UNUSED_LABEL,
+			(void*)&&ZEND_BACKUP_CV_SPEC_CV_UNUSED_LABEL,
+			(void*)&&ZEND_RESTORE_CV_SPEC_VAR_UNUSED_LABEL,
 			(void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
 			(void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
@@ -117192,6 +117497,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INIT_USING_SPEC_CONST_UNUSED):
+				VM_TRACE(ZEND_INIT_USING_SPEC_CONST_UNUSED)
+				ZEND_INIT_USING_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_INIT_USING_SPEC_CONST_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_DIV_SPEC_CONST_CV):
 				VM_TRACE(ZEND_DIV_SPEC_CONST_CV)
 				ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -118611,6 +118921,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INIT_USING_SPEC_TMP_UNUSED):
+				VM_TRACE(ZEND_INIT_USING_SPEC_TMP_UNUSED)
+				ZEND_INIT_USING_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_INIT_USING_SPEC_TMP_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV):
 				VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV)
 				ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -119385,6 +119700,16 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INIT_USING_SPEC_VAR_UNUSED):
+				VM_TRACE(ZEND_INIT_USING_SPEC_VAR_UNUSED)
+				ZEND_INIT_USING_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_INIT_USING_SPEC_VAR_UNUSED)
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_RESTORE_CV_SPEC_VAR_UNUSED):
+				VM_TRACE(ZEND_RESTORE_CV_SPEC_VAR_UNUSED)
+				ZEND_RESTORE_CV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_RESTORE_CV_SPEC_VAR_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED):
 				VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED)
 				ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -121124,6 +121449,16 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_CV_UNUSED)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INIT_USING_SPEC_CV_UNUSED):
+				VM_TRACE(ZEND_INIT_USING_SPEC_CV_UNUSED)
+				ZEND_INIT_USING_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_INIT_USING_SPEC_CV_UNUSED)
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_BACKUP_CV_SPEC_CV_UNUSED):
+				VM_TRACE(ZEND_BACKUP_CV_SPEC_CV_UNUSED)
+				ZEND_BACKUP_CV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_BACKUP_CV_SPEC_CV_UNUSED)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED):
 				VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED)
 				ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -124060,6 +124395,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_INIT_USING_SPEC_CONST_UNUSED_HANDLER,
+		ZEND_INIT_USING_SPEC_TMP_UNUSED_HANDLER,
+		ZEND_INIT_USING_SPEC_VAR_UNUSED_HANDLER,
+		ZEND_NULL_HANDLER,
+		ZEND_INIT_USING_SPEC_CV_UNUSED_HANDLER,
+		ZEND_BACKUP_CV_SPEC_CV_UNUSED_HANDLER,
+		ZEND_RESTORE_CV_SPEC_VAR_UNUSED_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_HANDLER,
 		ZEND_NULL_HANDLER,
@@ -127557,6 +127899,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_INIT_USING_SPEC_CONST_UNUSED_TAILCALL_HANDLER,
+		ZEND_INIT_USING_SPEC_TMP_UNUSED_TAILCALL_HANDLER,
+		ZEND_INIT_USING_SPEC_VAR_UNUSED_TAILCALL_HANDLER,
+		ZEND_NULL_TAILCALL_HANDLER,
+		ZEND_INIT_USING_SPEC_CV_UNUSED_TAILCALL_HANDLER,
+		ZEND_BACKUP_CV_SPEC_CV_UNUSED_TAILCALL_HANDLER,
+		ZEND_RESTORE_CV_SPEC_VAR_UNUSED_TAILCALL_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER,
 		ZEND_NULL_TAILCALL_HANDLER,
@@ -128525,7 +128874,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,
@@ -128559,7 +128908,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,
@@ -128691,51 +129040,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_OP1,
+		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)
@@ -128912,7 +129261,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);
 				}
@@ -128920,7 +129269,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);
 				}
@@ -128928,7 +129277,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);
 				}
@@ -128939,17 +129288,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:
@@ -128960,17 +129309,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:
@@ -128981,16 +129330,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:
@@ -129001,16 +129350,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:
@@ -129021,12 +129370,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:
@@ -129037,12 +129386,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:
@@ -129050,12 +129399,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:
@@ -129063,79 +129412,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:
@@ -129143,22 +129492,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..c1553eecd64a1 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1373,508 +1373,514 @@
 	_(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_INIT_USING_SPEC_CONST_UNUSED) \
+	_(2579, ZEND_INIT_USING_SPEC_TMP_UNUSED) \
+	_(2580, ZEND_INIT_USING_SPEC_VAR_UNUSED) \
+	_(2582, ZEND_INIT_USING_SPEC_CV_UNUSED) \
+	_(2583, ZEND_BACKUP_CV_SPEC_CV_UNUSED) \
+	_(2584, ZEND_RESTORE_CV_SPEC_VAR_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 936a96e55e41f..3f053e26c7472 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_INIT_USING",
+	"ZEND_BACKUP_CV",
+	"ZEND_RESTORE_CV",
 };
 
-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,
+	0x00000103,
+	0x00000101,
+	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..b39c4a74aecd5 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_INIT_USING                     211
+#define ZEND_BACKUP_CV                      212
+#define ZEND_RESTORE_CV                     213
 
-#define ZEND_VM_LAST_OPCODE                 210
+#define ZEND_VM_LAST_OPCODE                 213
 
 #endif
diff --git a/configure.ac b/configure.ac
index 77fc8c89cdf40..027b4ad36fa71 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1743,6 +1743,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([
     zend_closures.c
     zend_compile.c
     zend_constants.c
+    zend_context_managers.c
     zend_cpuinfo.c
     zend_default_classes.c
     zend_dtrace.c
diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index 0900c51d3d95a..6509dc39126d6 100644
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -120,6 +120,7 @@ char *get_token_type_name(int token_type)
 		case T_FUNC_C: return "T_FUNC_C";
 		case T_PROPERTY_C: return "T_PROPERTY_C";
 		case T_NS_C: return "T_NS_C";
+		case T_WITH: return "T_WITH";
 		case T_ATTRIBUTE: return "T_ATTRIBUTE";
 		case T_PLUS_EQUAL: return "T_PLUS_EQUAL";
 		case T_MINUS_EQUAL: return "T_MINUS_EQUAL";
diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php
index 57c8edad8acb6..552e2f093513c 100644
--- a/ext/tokenizer/tokenizer_data.stub.php
+++ b/ext/tokenizer/tokenizer_data.stub.php
@@ -477,6 +477,11 @@
  * @cvalue T_NS_C
  */
 const T_NS_C = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_WITH
+ */
+const T_WITH = UNKNOWN;
 /**
  * @var int
  * @cvalue T_ATTRIBUTE
diff --git a/win32/build/config.w32 b/win32/build/config.w32
index 403f0aa6efbfe..1b71b73fb8e8e 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_context_managers.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({