diff --git a/UPGRADING.INTERNALS b/UPGRADING.INTERNALS
index a52196dc609..47c42d48d42 100644
--- a/UPGRADING.INTERNALS
+++ b/UPGRADING.INTERNALS
@@ -51,6 +51,7 @@ PHP 8.2 INTERNALS UPGRADE NOTES
   are deprecated (see main UPGRADING notes). To suppress the notice, e.g. to
   avoid duplicates when processing the same value multiple times, pass or add
   IS_CALLABLE_SUPPRESS_DEPRECATIONS to the check_flags parameter.
+* Registered zend_observer_fcall_init handlers are now also called for internal functions.
 
 ========================
 2. Build system changes
diff --git a/Zend/zend.c b/Zend/zend.c
index ef1fe3d9d05..6eeba07d7fa 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -1226,6 +1226,7 @@ ZEND_API void zend_activate(void) /* {{{ */
 	if (CG(map_ptr_last)) {
 		memset(CG(map_ptr_real_base), 0, CG(map_ptr_last) * sizeof(void*));
 	}
+	zend_init_internal_run_time_cache();
 	zend_observer_activate();
 }
 /* }}} */
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index f366a3b7ae6..90787376a62 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -2694,6 +2694,11 @@ ZEND_API zend_result zend_register_functions(zend_class_entry *scope, const zend
 		internal_function->scope = scope;
 		internal_function->prototype = NULL;
 		internal_function->attributes = NULL;
+		if (EG(active)) { // at run-time: this ought to only happen if registered with dl() or somehow temporarily at runtime
+			ZEND_MAP_PTR_INIT(internal_function->run_time_cache, zend_arena_alloc(&CG(arena), zend_internal_run_time_cache_reserved_size()));
+		} else {
+			ZEND_MAP_PTR_NEW(internal_function->run_time_cache);
+		}
 		if (ptr->flags) {
 			if (!(ptr->flags & ZEND_ACC_PPP_MASK)) {
 				if (ptr->flags != ZEND_ACC_DEPRECATED && scope) {
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index c57b7c1d616..2467c92b514 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -33,6 +33,7 @@
 #include "zend_inheritance.h"
 #include "zend_vm.h"
 #include "zend_enum.h"
+#include "zend_observer.h"
 
 #define SET_NODE(target, src) do { \
 		target ## _type = (src)->op_type; \
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 89c1b1f6579..5bcb1a58ec4 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -448,6 +448,7 @@ struct _zend_op_array {
 	uint32_t required_num_args;
 	zend_arg_info *arg_info;
 	HashTable *attributes;
+	ZEND_MAP_PTR_DEF(void **, run_time_cache);
 	/* END of common elements */
 
 	int cache_size;     /* number of run_time_cache_slots * sizeof(void*) */
@@ -456,7 +457,6 @@ struct _zend_op_array {
 	uint32_t last;      /* number of opcodes */
 
 	zend_op *opcodes;
-	ZEND_MAP_PTR_DEF(void **, run_time_cache);
 	ZEND_MAP_PTR_DEF(HashTable *, static_variables_ptr);
 	HashTable *static_variables;
 	zend_string **vars; /* names of CV variables */
@@ -503,6 +503,7 @@ typedef struct _zend_internal_function {
 	uint32_t required_num_args;
 	zend_internal_arg_info *arg_info;
 	HashTable *attributes;
+	ZEND_MAP_PTR_DEF(void **, run_time_cache);
 	/* END of common elements */
 
 	zif_handler handler;
@@ -527,6 +528,7 @@ union _zend_function {
 		uint32_t required_num_args;
 		zend_arg_info *arg_info;  /* index -1 represents the return value info, if any */
 		HashTable   *attributes;
+		ZEND_MAP_PTR_DEF(void **, run_time_cache);
 	} common;
 
 	zend_op_array op_array;
diff --git a/Zend/zend_enum.c b/Zend/zend_enum.c
index 39e0ad58ee1..288e019c913 100644
--- a/Zend/zend_enum.c
+++ b/Zend/zend_enum.c
@@ -22,6 +22,7 @@
 #include "zend_enum_arginfo.h"
 #include "zend_interfaces.h"
 #include "zend_enum.h"
+#include "zend_extensions.h"
 
 #define ZEND_ENUM_DISALLOW_MAGIC_METHOD(propertyName, methodName) \
 	do { \
@@ -401,59 +402,48 @@ static ZEND_NAMED_FUNCTION(zend_enum_try_from_func)
 	zend_enum_from_base(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
 }
 
+static void zend_enum_register_func(zend_class_entry *ce, zend_known_string_id name_id, zend_internal_function *zif) {
+	zend_string *name = ZSTR_KNOWN(name_id);
+	zif->type = ZEND_INTERNAL_FUNCTION;
+	zif->module = EG(current_module);
+	zif->scope = ce;
+	ZEND_MAP_PTR_NEW(zif->run_time_cache);
+	ZEND_MAP_PTR_SET(zif->run_time_cache, zend_arena_alloc(&CG(arena), zend_internal_run_time_cache_reserved_size()));
+
+	if (!zend_hash_add_ptr(&ce->function_table, name, zif)) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", ZSTR_VAL(ce->name), ZSTR_VAL(name));
+	}
+}
+
 void zend_enum_register_funcs(zend_class_entry *ce)
 {
 	const uint32_t fn_flags =
 		ZEND_ACC_PUBLIC|ZEND_ACC_STATIC|ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_ARENA_ALLOCATED;
-	zend_internal_function *cases_function =
-		zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
-	memset(cases_function, 0, sizeof(zend_internal_function));
-	cases_function->type = ZEND_INTERNAL_FUNCTION;
-	cases_function->module = EG(current_module);
+	zend_internal_function *cases_function = zend_arena_calloc(&CG(arena), sizeof(zend_internal_function), 1);
 	cases_function->handler = zend_enum_cases_func;
 	cases_function->function_name = ZSTR_KNOWN(ZEND_STR_CASES);
-	cases_function->scope = ce;
 	cases_function->fn_flags = fn_flags;
 	cases_function->arg_info = (zend_internal_arg_info *) (arginfo_class_UnitEnum_cases + 1);
-	if (!zend_hash_add_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_CASES), cases_function)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::cases()", ZSTR_VAL(ce->name));
-	}
+	zend_enum_register_func(ce, ZEND_STR_CASES, cases_function);
 
 	if (ce->enum_backing_type != IS_UNDEF) {
-		zend_internal_function *from_function =
-			zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
-		memset(from_function, 0, sizeof(zend_internal_function));
-		from_function->type = ZEND_INTERNAL_FUNCTION;
-		from_function->module = EG(current_module);
+		zend_internal_function *from_function = zend_arena_calloc(&CG(arena), sizeof(zend_internal_function), 1);
 		from_function->handler = zend_enum_from_func;
 		from_function->function_name = ZSTR_KNOWN(ZEND_STR_FROM);
-		from_function->scope = ce;
 		from_function->fn_flags = fn_flags;
 		from_function->num_args = 1;
 		from_function->required_num_args = 1;
 		from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_BackedEnum_from + 1);
-		if (!zend_hash_add_ptr(&ce->function_table, ZSTR_KNOWN(ZEND_STR_FROM), from_function)) {
-			zend_error_noreturn(E_COMPILE_ERROR,
-				"Cannot redeclare %s::from()", ZSTR_VAL(ce->name));
-		}
+		zend_enum_register_func(ce, ZEND_STR_FROM, from_function);
 
-		zend_internal_function *try_from_function =
-			zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
-		memset(try_from_function, 0, sizeof(zend_internal_function));
-		try_from_function->type = ZEND_INTERNAL_FUNCTION;
-		try_from_function->module = EG(current_module);
+		zend_internal_function *try_from_function = zend_arena_calloc(&CG(arena), sizeof(zend_internal_function), 1);
 		try_from_function->handler = zend_enum_try_from_func;
 		try_from_function->function_name = ZSTR_KNOWN(ZEND_STR_TRYFROM);
-		try_from_function->scope = ce;
 		try_from_function->fn_flags = fn_flags;
 		try_from_function->num_args = 1;
 		try_from_function->required_num_args = 1;
 		try_from_function->arg_info = (zend_internal_arg_info *) (arginfo_class_BackedEnum_tryFrom + 1);
-		if (!zend_hash_add_ptr(
-				&ce->function_table, ZSTR_KNOWN(ZEND_STR_TRYFROM_LOWERCASE), try_from_function)) {
-			zend_error_noreturn(E_COMPILE_ERROR,
-				"Cannot redeclare %s::tryFrom()", ZSTR_VAL(ce->name));
-		}
+		zend_enum_register_func(ce, ZEND_STR_TRYFROM_LOWERCASE, try_from_function);
 	}
 }
 
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index adc875e2a77..45cf790bfa8 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -144,6 +144,7 @@ ZEND_API const zend_internal_function zend_pass_function = {
 	0,                      /* required_num_args */
 	(zend_internal_arg_info *) zend_pass_function_arg_info + 1, /* arg_info */
 	NULL,                   /* attributes        */
+	NULL,                   /* run_time_cache    */
 	ZEND_FN(pass),          /* handler           */
 	NULL,                   /* module            */
 	{NULL,NULL,NULL,NULL}   /* reserved          */
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 755bc2cd2c9..a46959373ad 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -935,6 +935,7 @@ cleanup_args:
 #if ZEND_DEBUG
 		bool should_throw = zend_internal_call_should_throw(func, call);
 #endif
+		ZEND_OBSERVER_FCALL_BEGIN(call);
 		if (EXPECTED(zend_execute_internal == NULL)) {
 			/* saves one function call if zend_execute_internal is not used */
 			func->internal_function.handler(call, fci->retval);
@@ -953,6 +954,7 @@ cleanup_args:
 				? Z_ISREF_P(fci->retval) : !Z_ISREF_P(fci->retval));
 		}
 #endif
+		ZEND_OBSERVER_FCALL_END(call, fci->retval);
 		EG(current_execute_data) = call->prev_execute_data;
 		zend_vm_stack_free_args(call);
 		if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
diff --git a/Zend/zend_extensions.c b/Zend/zend_extensions.c
index cbad169732e..1f3687642ab 100644
--- a/Zend/zend_extensions.c
+++ b/Zend/zend_extensions.c
@@ -280,6 +280,40 @@ ZEND_API int zend_get_op_array_extension_handles(const char *module_name, int ha
 	return handle;
 }
 
+ZEND_API size_t zend_internal_run_time_cache_reserved_size() {
+	return zend_op_array_extension_handles * sizeof(void *);
+}
+
+ZEND_API void zend_init_internal_run_time_cache() {
+	size_t rt_size = zend_internal_run_time_cache_reserved_size();
+	if (rt_size) {
+		size_t functions = zend_hash_num_elements(CG(function_table));
+		zend_class_entry *ce;
+		ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
+			functions += zend_hash_num_elements(&ce->function_table);
+		} ZEND_HASH_FOREACH_END();
+
+		char *ptr = zend_arena_calloc(&CG(arena), functions, rt_size);
+		zend_internal_function *zif;
+		ZEND_HASH_MAP_FOREACH_PTR(CG(function_table), zif) {
+			if (!ZEND_USER_CODE(zif->type) && ZEND_MAP_PTR_GET(zif->run_time_cache) == NULL)
+			{
+				ZEND_MAP_PTR_SET(zif->run_time_cache, (void *)ptr);
+				ptr += rt_size;
+			}
+		} ZEND_HASH_FOREACH_END();
+		ZEND_HASH_MAP_FOREACH_PTR(CG(class_table), ce) {
+			ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, zif) {
+				if (!ZEND_USER_CODE(zif->type) && ZEND_MAP_PTR_GET(zif->run_time_cache) == NULL)
+				{
+					ZEND_MAP_PTR_SET(zif->run_time_cache, (void *)ptr);
+					ptr += rt_size;
+				}
+			} ZEND_HASH_FOREACH_END();
+		} ZEND_HASH_FOREACH_END();
+	}
+}
+
 ZEND_API zend_extension *zend_get_extension(const char *extension_name)
 {
 	zend_llist_element *element;
diff --git a/Zend/zend_extensions.h b/Zend/zend_extensions.h
index 95eb8dd10ef..c32ed5de1ad 100644
--- a/Zend/zend_extensions.h
+++ b/Zend/zend_extensions.h
@@ -145,6 +145,9 @@ void zend_startup_extensions_mechanism(void);
 void zend_startup_extensions(void);
 void zend_shutdown_extensions(void);
 
+ZEND_API size_t zend_internal_run_time_cache_reserved_size(void);
+ZEND_API void zend_init_internal_run_time_cache(void);
+
 BEGIN_EXTERN_C()
 ZEND_API zend_result zend_load_extension(const char *path);
 ZEND_API zend_result zend_load_extension_handle(DL_HANDLE handle, const char *path);
diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c
index 5b6499fefc8..8151ef74fab 100644
--- a/Zend/zend_observer.c
+++ b/Zend/zend_observer.c
@@ -23,13 +23,13 @@
 #include "zend_llist.h"
 #include "zend_vm.h"
 
-#define ZEND_OBSERVER_DATA(op_array) \
-	ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension)
+#define ZEND_OBSERVER_DATA(function) \
+	ZEND_OP_ARRAY_EXTENSION((&(function)->common), zend_observer_fcall_op_array_extension)
 
 #define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2)
 
-#define ZEND_OBSERVABLE_FN(fn_flags) \
-	(!(fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
+#define ZEND_OBSERVABLE_FN(function) \
+	(ZEND_MAP_PTR(function->common.run_time_cache) && !(function->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
 
 zend_llist zend_observers_fcall_list;
 zend_llist zend_observer_error_callbacks;
@@ -100,12 +100,9 @@ static void zend_observer_fcall_install(zend_execute_data *execute_data)
 {
 	zend_llist *list = &zend_observers_fcall_list;
 	zend_function *function = execute_data->func;
-	zend_op_array *op_array = &function->op_array;
 
-	ZEND_ASSERT(function->type != ZEND_INTERNAL_FUNCTION);
-
-	ZEND_ASSERT(RUN_TIME_CACHE(op_array));
-	zend_observer_fcall_begin_handler *begin_handlers = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(op_array);
+	ZEND_ASSERT(RUN_TIME_CACHE(&function->common));
+	zend_observer_fcall_begin_handler *begin_handlers = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(function);
 	zend_observer_fcall_end_handler *end_handlers = (zend_observer_fcall_end_handler *)begin_handlers + list->count, *end_handlers_start = end_handlers;
 
 	*begin_handlers = ZEND_OBSERVER_NOT_OBSERVED;
@@ -152,9 +149,9 @@ static bool zend_observer_remove_handler(void **first_handler, void *old_handler
 	return false;
 }
 
-ZEND_API void zend_observer_add_begin_handler(zend_op_array *op_array, zend_observer_fcall_begin_handler begin) {
+ZEND_API void zend_observer_add_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin) {
 	size_t registered_observers = zend_observers_fcall_list.count;
-	zend_observer_fcall_begin_handler *first_handler = (void *)&ZEND_OBSERVER_DATA(op_array), *last_handler = first_handler + registered_observers - 1;
+	zend_observer_fcall_begin_handler *first_handler = (void *)&ZEND_OBSERVER_DATA(function), *last_handler = first_handler + registered_observers - 1;
 	if (*first_handler == ZEND_OBSERVER_NOT_OBSERVED) {
 		*first_handler = begin;
 	} else {
@@ -169,13 +166,13 @@ ZEND_API void zend_observer_add_begin_handler(zend_op_array *op_array, zend_obse
 	}
 }
 
-ZEND_API bool zend_observer_remove_begin_handler(zend_op_array *op_array, zend_observer_fcall_begin_handler begin) {
-	return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(op_array), begin);
+ZEND_API bool zend_observer_remove_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin) {
+	return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(function), begin);
 }
 
-ZEND_API void zend_observer_add_end_handler(zend_op_array *op_array, zend_observer_fcall_end_handler end) {
+ZEND_API void zend_observer_add_end_handler(zend_function *function, zend_observer_fcall_end_handler end) {
 	size_t registered_observers = zend_observers_fcall_list.count;
-	zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(op_array) + registered_observers;
+	zend_observer_fcall_end_handler *end_handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(function) + registered_observers;
 	// to allow to preserve the invariant that end handlers are in reverse order of begin handlers, push the new end handler in front
 	if (*end_handler != ZEND_OBSERVER_NOT_OBSERVED) {
 		// there's no space for new handlers, then it's forbidden to call this function
@@ -185,9 +182,9 @@ ZEND_API void zend_observer_add_end_handler(zend_op_array *op_array, zend_observ
 	*end_handler = end;
 }
 
-ZEND_API bool zend_observer_remove_end_handler(zend_op_array *op_array, zend_observer_fcall_end_handler end) {
+ZEND_API bool zend_observer_remove_end_handler(zend_function *function, zend_observer_fcall_end_handler end) {
 	size_t registered_observers = zend_observers_fcall_list.count;
-	return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(op_array) + registered_observers, end);
+	return zend_observer_remove_handler((void **)&ZEND_OBSERVER_DATA(function) + registered_observers, end);
 }
 
 static void ZEND_FASTCALL _zend_observe_fcall_begin(zend_execute_data *execute_data)
@@ -196,14 +193,13 @@ static void ZEND_FASTCALL _zend_observe_fcall_begin(zend_execute_data *execute_d
 		return;
 	}
 
-	zend_op_array *op_array = &execute_data->func->op_array;
-	uint32_t fn_flags = op_array->fn_flags;
+	zend_function *function = execute_data->func;
 
-	if (!ZEND_OBSERVABLE_FN(fn_flags)) {
+	if (!ZEND_OBSERVABLE_FN(function)) {
 		return;
 	}
 
-	zend_observer_fcall_begin_handler *handler = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(op_array);
+	zend_observer_fcall_begin_handler *handler = (zend_observer_fcall_begin_handler *)&ZEND_OBSERVER_DATA(function);
 	if (!*handler) {
 		zend_observer_fcall_install(execute_data);
 	}
@@ -243,11 +239,11 @@ ZEND_API void ZEND_FASTCALL zend_observer_fcall_begin(zend_execute_data *execute
 static inline bool zend_observer_is_skipped_frame(zend_execute_data *execute_data) {
 	zend_function *func = execute_data->func;
 
-	if (!func || func->type == ZEND_INTERNAL_FUNCTION || !ZEND_OBSERVABLE_FN(func->common.fn_flags)) {
+	if (!func || !ZEND_OBSERVABLE_FN(func)) {
 		return true;
 	}
 
-	zend_observer_fcall_end_handler end_handler = (&ZEND_OBSERVER_DATA(&func->op_array))[zend_observers_fcall_list.count];
+	zend_observer_fcall_end_handler end_handler = (&ZEND_OBSERVER_DATA(func))[zend_observers_fcall_list.count];
 	if (end_handler == NULL || end_handler == ZEND_OBSERVER_NOT_OBSERVED) {
 		return true;
 	}
@@ -259,11 +255,11 @@ ZEND_API void ZEND_FASTCALL zend_observer_fcall_end(zend_execute_data *execute_d
 {
 	zend_function *func = execute_data->func;
 
-	if (!ZEND_OBSERVER_ENABLED || !ZEND_OBSERVABLE_FN(func->common.fn_flags)) {
+	if (!ZEND_OBSERVER_ENABLED || !ZEND_OBSERVABLE_FN(func)) {
 		return;
 	}
 
-	zend_observer_fcall_end_handler *handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(&func->op_array) + zend_observers_fcall_list.count;
+	zend_observer_fcall_end_handler *handler = (zend_observer_fcall_end_handler *)&ZEND_OBSERVER_DATA(func) + zend_observers_fcall_list.count;
 	// TODO: Fix exceptions from generators
 	// ZEND_ASSERT(fcall_data);
 	if (!*handler || *handler == ZEND_OBSERVER_NOT_OBSERVED) {
@@ -291,7 +287,7 @@ ZEND_API void zend_observer_fcall_end_all(void)
 {
 	zend_execute_data *ex = current_observed_frame;
 	while (ex != NULL) {
-		if (ex->func && ex->func->type != ZEND_INTERNAL_FUNCTION) {
+		if (ex->func) {
 			zend_observer_fcall_end(ex, NULL);
 		}
 		ex = ex->prev_execute_data;
diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h
index 2197073d10f..ebd5c0ce62a 100644
--- a/Zend/zend_observer.h
+++ b/Zend/zend_observer.h
@@ -58,10 +58,10 @@ ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init);
 
 // Call during runtime, but only if you have used zend_observer_fcall_register.
 // You must not have more than one begin and one end handler active at the same time. Remove the old one first, if there is an existing one.
-ZEND_API void zend_observer_add_begin_handler(zend_op_array *op_array, zend_observer_fcall_begin_handler begin);
-ZEND_API bool zend_observer_remove_begin_handler(zend_op_array *op_array, zend_observer_fcall_begin_handler begin);
-ZEND_API void zend_observer_add_end_handler(zend_op_array *op_array, zend_observer_fcall_end_handler end);
-ZEND_API bool zend_observer_remove_end_handler(zend_op_array *op_array, zend_observer_fcall_end_handler end);
+ZEND_API void zend_observer_add_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin);
+ZEND_API bool zend_observer_remove_begin_handler(zend_function *function, zend_observer_fcall_begin_handler begin);
+ZEND_API void zend_observer_add_end_handler(zend_function *function, zend_observer_fcall_end_handler end);
+ZEND_API bool zend_observer_remove_end_handler(zend_function *function, zend_observer_fcall_end_handler end);
 
 ZEND_API void zend_observer_startup(void); // Called by engine before MINITs
 ZEND_API void zend_observer_post_startup(void); // Called by engine after MINITs
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 86557b6e2bf..df042aa8f31 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -405,7 +405,7 @@ ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(NO_CONST_
 			}
 		} else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -1998,9 +1998,9 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, CONST|TMP|VAR|CV, C
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
+		if ((OP1_TYPE & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_DISPATCH_TO_HELPER(zend_use_tmp_in_write_context_helper);
-        }
+		}
 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_FETCH_DIM_W);
 	} else {
 		if (OP2_TYPE == IS_UNUSED) {
@@ -2036,7 +2036,7 @@ ZEND_VM_HOT_OBJ_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMPVAR|UNUSED|THIS|CV, CONST
 
 	if (OP1_TYPE == IS_CONST ||
 	    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -2084,9 +2084,9 @@ ZEND_VM_C_LABEL(fetch_obj_r_fast_copy):
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
 									ZEND_VM_C_GOTO(fetch_obj_r_copy);
@@ -2248,9 +2248,9 @@ ZEND_VM_C_LABEL(fetch_obj_is_fast_copy):
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) {
 									ZEND_VM_C_GOTO(fetch_obj_is_copy);
@@ -3161,7 +3161,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(53, ZEND_FAST_CONCAT, CONST|TMPVAR|CV, CONST|TMP
 			}
 		} else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -3503,9 +3503,9 @@ ZEND_VM_HOT_OBJ_HANDLER(112, ZEND_INIT_METHOD_CALL, CONST|TMPVAR|UNUSED|THIS|CV,
 
 	if (OP2_TYPE == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (OP2_TYPE == IS_CONST) {
 			function_name = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
@@ -3908,7 +3908,7 @@ ZEND_VM_HOT_HANDLER(61, ZEND_INIT_FCALL, NUM, CONST, NUM|CACHE_SLOT)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 {
 	USE_OPLINE
 	zend_execute_data *call = EX(call);
@@ -3929,6 +3929,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL))
 	ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
 	ZVAL_NULL(ret);
 
+	ZEND_OBSERVER_FCALL_BEGIN(call);
 	fbc->internal_function.handler(call, ret);
 
 #if ZEND_DEBUG
@@ -3943,6 +3944,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL))
 		zend_verify_internal_func_info(call->func, ret);
 	}
 #endif
+	ZEND_OBSERVER_FCALL_END(call, EG(exception) ? NULL : ret);
 
 	EG(current_execute_data) = execute_data;
 	zend_vm_stack_free_args(call);
@@ -4048,6 +4050,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER))
 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
 		ZVAL_NULL(ret);
 
+		ZEND_OBSERVER_FCALL_BEGIN(call);
 		fbc->internal_function.handler(call, ret);
 
 #if ZEND_DEBUG
@@ -4062,6 +4065,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER))
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		ZEND_OBSERVER_FCALL_END(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = execute_data;
 
@@ -4153,6 +4157,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
 		ZVAL_NULL(ret);
 
+		ZEND_OBSERVER_FCALL_BEGIN(call);
 		if (!zend_execute_internal) {
 			/* saves one function call if zend_execute_internal is not used */
 			fbc->internal_function.handler(call, ret);
@@ -4172,6 +4177,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		ZEND_OBSERVER_FCALL_END(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = execute_data;
 
@@ -5782,7 +5788,7 @@ ZEND_VM_COLD_CONST_HANDLER(110, ZEND_CLONE, CONST|TMPVAR|UNUSED|THIS|CV, ANY)
 	do {
 		if (OP1_TYPE == IS_CONST ||
 		    (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
-		    if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+			if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
 				obj = Z_REFVAL_P(obj);
 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
 					break;
@@ -6301,7 +6307,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSER
 		new_op_array->scope = EX(func)->op_array.scope;
 
 		call = zend_vm_stack_push_call_frame(
-		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+			(Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
 			(zend_function*)new_op_array, 0,
 			Z_PTR(EX(This)));
 
@@ -8129,7 +8135,7 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMPVAR|CV|UNUSED
 				}
 			} else if (OP1_TYPE == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 				FREE_OP1_IF_VAR();
 			} else {
@@ -8364,9 +8370,9 @@ ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST, CACHE_SLOT)
 		Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
 
 		if (EXPECTED(p->key == varname) ||
-	        (EXPECTED(p->h == ZSTR_H(varname)) &&
-	         EXPECTED(p->key != NULL) &&
-	         EXPECTED(zend_string_equal_content(p->key, varname)))) {
+		    (EXPECTED(p->h == ZSTR_H(varname)) &&
+		     EXPECTED(p->key != NULL) &&
+		     EXPECTED(zend_string_equal_content(p->key, varname)))) {
 
 			value = (zval*)p; /* value = &p->val; */
 			ZEND_VM_C_GOTO(check_indirect);
@@ -8710,6 +8716,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER))
 		}
 
 		ZVAL_NULL(ret);
+		ZEND_OBSERVER_FCALL_BEGIN(call);
 		if (!zend_execute_internal) {
 			/* saves one function call if zend_execute_internal is not used */
 			fbc->internal_function.handler(call, ret);
@@ -8729,6 +8736,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER))
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		ZEND_OBSERVER_FCALL_END(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = call->prev_execute_data;
 
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 13ba7443360..b3a48b80f48 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1350,6 +1350,70 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_RETV
 	ZEND_VM_CONTINUE();
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+	zval retval;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	call->prev_execute_data = execute_data;
+	EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+	bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+	ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
+	ZVAL_NULL(ret);
+
+	zend_observer_fcall_begin(call);
+	fbc->internal_function.handler(call, ret);
+
+#if ZEND_DEBUG
+	if (!EG(exception) && call->func) {
+		if (should_throw) {
+			zend_internal_call_arginfo_violation(call->func);
+		}
+		ZEND_ASSERT(!(call->func->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) ||
+			zend_verify_internal_return_type(call->func, ret));
+		ZEND_ASSERT((call->func->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
+			? Z_ISREF_P(ret) : !Z_ISREF_P(ret));
+		zend_verify_internal_func_info(call->func, ret);
+	}
+#endif
+	zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
+
+	EG(current_execute_data) = execute_data;
+	zend_vm_stack_free_args(call);
+
+	uint32_t call_info = ZEND_CALL_INFO(call);
+	if (UNEXPECTED(call_info & (ZEND_CALL_HAS_EXTRA_NAMED_PARAMS|ZEND_CALL_ALLOCATED))) {
+		if (call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS) {
+			zend_free_extra_named_params(call->extra_named_params);
+		}
+		zend_vm_stack_free_call_frame_ex(call_info, call);
+	} else {
+		EG(vm_stack_top) = (zval*)call;
+	}
+
+	if (!RETURN_VALUE_USED(opline)) {
+		i_zval_ptr_dtor(ret);
+	}
+
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		zend_rethrow_exception(execute_data);
+		HANDLE_EXCEPTION();
+	}
+
+	ZEND_VM_SET_OPCODE(opline + 1);
+	ZEND_VM_CONTINUE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -1666,6 +1730,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_
 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
 		ZVAL_NULL(ret);
 
+		zend_observer_fcall_begin(call);
 		fbc->internal_function.handler(call, ret);
 
 #if ZEND_DEBUG
@@ -1680,6 +1745,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = execute_data;
 
@@ -1989,6 +2055,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS
 		ret = RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : &retval;
 		ZVAL_NULL(ret);
 
+		zend_observer_fcall_begin(call);
 		if (!zend_execute_internal) {
 			/* saves one function call if zend_execute_internal is not used */
 			fbc->internal_function.handler(call, ret);
@@ -2008,6 +2075,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_OBS
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = execute_data;
 
@@ -3342,6 +3410,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z
 		}
 
 		ZVAL_NULL(ret);
+
 		if (!zend_execute_internal) {
 			/* saves one function call if zend_execute_internal is not used */
 			fbc->internal_function.handler(call, ret);
@@ -3479,6 +3548,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_
 		}
 
 		ZVAL_NULL(ret);
+		zend_observer_fcall_begin(call);
 		if (!zend_execute_internal) {
 			/* saves one function call if zend_execute_internal is not used */
 			fbc->internal_function.handler(call, ret);
@@ -3498,6 +3568,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_
 			zend_verify_internal_func_info(call->func, ret);
 		}
 #endif
+		zend_observer_fcall_end(call, EG(exception) ? NULL : ret);
 
 		EG(current_execute_data) = call->prev_execute_data;
 
@@ -4677,7 +4748,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_
 	do {
 		if (IS_CONST == IS_CONST ||
 		    (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
-		    if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+			if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
 				obj = Z_REFVAL_P(obj);
 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
 					break;
@@ -4865,7 +4936,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN
 		new_op_array->scope = EX(func)->op_array.scope;
 
 		call = zend_vm_stack_push_call_frame(
-		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+			(Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
 			(zend_function*)new_op_array, 0,
 			Z_PTR(EX(This)));
 
@@ -4948,7 +5019,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_
 		new_op_array->scope = EX(func)->op_array.scope;
 
 		call = zend_vm_stack_push_call_frame(
-		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+			(Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
 			(zend_function*)new_op_array, 0,
 			Z_PTR(EX(This)));
 
@@ -6210,9 +6281,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_AR
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CONST == IS_UNUSED) {
@@ -6233,7 +6304,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
 
 	if (IS_CONST == IS_CONST ||
 	    (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -6281,9 +6352,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -6407,9 +6478,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -6525,7 +6596,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_
 			}
 		} else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -6698,9 +6769,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
 
 	if (IS_CONST == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CONST == IS_CONST) {
 			function_name = RT_CONSTANT(opline, opline->op2);
@@ -7500,7 +7571,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER
 				}
 			} else if (IS_CONST == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -8438,7 +8509,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDL
 			}
 		} else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -8547,9 +8618,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
@@ -8570,7 +8641,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
 
 	if (IS_CONST == IS_CONST ||
 	    (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -8618,9 +8689,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -8744,9 +8815,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -8862,7 +8933,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_
 			}
 		} else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -9035,9 +9106,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
 			function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
@@ -9646,7 +9717,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLE
 				}
 			} else if (IS_CONST == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -9836,9 +9907,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_UNUSED == IS_UNUSED) {
@@ -10489,7 +10560,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLE
 				}
 			} else if (IS_CONST == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -10803,7 +10874,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(Z
 			}
 		} else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -10912,9 +10983,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CV == IS_UNUSED) {
@@ -10935,7 +11006,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_
 
 	if (IS_CONST == IS_CONST ||
 	    (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -10983,9 +11054,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -11109,9 +11180,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -11227,7 +11298,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CONST_CV_HAND
 			}
 		} else if (IS_CONST != IS_CONST && IS_CONST != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -11400,9 +11471,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_
 
 	if (IS_CV == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CV == IS_CONST) {
 			function_name = EX_VAR(opline->op2.var);
@@ -12009,7 +12080,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
 				}
 			} else if (IS_CONST == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -14373,7 +14444,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND
 	do {
 		if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
 		    ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
-		    if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+			if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
 				obj = Z_REFVAL_P(obj);
 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
 					break;
@@ -14469,7 +14540,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
 		new_op_array->scope = EX(func)->op_array.scope;
 
 		call = zend_vm_stack_push_call_frame(
-		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+			(Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
 			(zend_function*)new_op_array, 0,
 			Z_PTR(EX(This)));
 
@@ -14833,7 +14904,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDL
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -15308,7 +15379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
 	    ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -15356,9 +15427,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -15482,9 +15553,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -15571,7 +15642,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -15744,9 +15815,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
 	if (IS_CONST == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CONST == IS_CONST) {
 			function_name = RT_CONSTANT(opline, opline->op2);
@@ -16269,7 +16340,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HAND
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -16744,7 +16815,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
 	    ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -16792,9 +16863,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -16918,9 +16989,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -17007,7 +17078,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -17180,9 +17251,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_T
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
 			function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
@@ -17956,7 +18027,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -18069,7 +18140,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HAN
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST ||
 	    ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -18117,9 +18188,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -18243,9 +18314,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -18332,7 +18403,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HAN
 			}
 		} else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -18505,9 +18576,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_C
 
 	if (IS_CV == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CV == IS_CONST) {
 			function_name = EX_VAR(opline->op2.var);
@@ -19472,9 +19543,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CO
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CONST == IS_UNUSED) {
@@ -19816,7 +19887,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(Z
 				}
 			} else if (IS_TMP_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -19949,9 +20020,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TM
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
@@ -20256,7 +20327,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(
 				}
 			} else if (IS_TMP_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -20376,9 +20447,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UN
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_UNUSED == IS_UNUSED) {
@@ -20717,7 +20788,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(
 				}
 			} else if (IS_TMP_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -20810,9 +20881,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CV == IS_UNUSED) {
@@ -21117,7 +21188,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND
 				}
 			} else if (IS_TMP_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -22806,9 +22877,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CO
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CONST == IS_UNUSED) {
@@ -24984,7 +25055,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(Z
 				}
 			} else if (IS_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			} else {
@@ -25511,9 +25582,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TM
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
@@ -27282,7 +27353,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(
 				}
 			} else if (IS_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			} else {
@@ -27676,9 +27747,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UN
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_UNUSED == IS_UNUSED) {
@@ -29181,7 +29252,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(
 				}
 			} else if (IS_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			} else {
@@ -29719,9 +29790,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CV == IS_UNUSED) {
@@ -31560,7 +31631,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND
 				}
 			} else if (IS_VAR == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			} else {
@@ -31765,7 +31836,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND
 	do {
 		if (IS_UNUSED == IS_CONST ||
 		    (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
-		    if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+			if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
 				obj = Z_REFVAL_P(obj);
 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
 					break;
@@ -32116,7 +32187,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R
 
 	if (IS_UNUSED == IS_CONST ||
 	    (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -32164,9 +32235,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -32333,9 +32404,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -33182,9 +33253,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S
 
 	if (IS_CONST == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CONST == IS_CONST) {
 			function_name = RT_CONSTANT(opline, opline->op2);
@@ -33691,7 +33762,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLE
 				}
 			} else if (IS_UNUSED == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -33988,7 +34059,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
 
 	if (IS_UNUSED == IS_CONST ||
 	    (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -34036,9 +34107,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -34200,9 +34271,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -35050,9 +35121,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_T
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
 			function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
@@ -35435,7 +35506,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDL
 				}
 			} else if (IS_UNUSED == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -35977,7 +36048,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDL
 				}
 			} else if (IS_UNUSED == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -36465,7 +36536,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
 
 	if (IS_UNUSED == IS_CONST ||
 	    (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -36513,9 +36584,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -36677,9 +36748,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -37526,9 +37597,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_C
 
 	if (IS_CV == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CV == IS_CONST) {
 			function_name = EX_VAR(opline->op2.var);
@@ -37910,7 +37981,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(Z
 				}
 			} else if (IS_UNUSED == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -38667,7 +38738,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPC
 	do {
 		if (IS_CV == IS_CONST ||
 		    (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) {
-		    if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
+			if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) {
 				obj = Z_REFVAL_P(obj);
 				if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) {
 					break;
@@ -38855,7 +38926,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
 		new_op_array->scope = EX(func)->op_array.scope;
 
 		call = zend_vm_stack_push_call_frame(
-		    (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
+			(Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE,
 			(zend_function*)new_op_array, 0,
 			Z_PTR(EX(This)));
 
@@ -39707,7 +39778,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(Z
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -40598,9 +40669,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CON
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CONST == IS_UNUSED) {
@@ -40636,7 +40707,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R
 
 	if (IS_CV == IS_CONST ||
 	    (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -40684,9 +40755,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -40853,9 +40924,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -42206,7 +42277,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CONST_HAND
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -42379,9 +42450,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_S
 
 	if (IS_CONST == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CONST == IS_CONST) {
 			function_name = RT_CONSTANT(opline, opline->op2);
@@ -43115,7 +43186,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZE
 				}
 			} else if (IS_CV == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -43188,9 +43259,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_C
 		Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
 
 		if (EXPECTED(p->key == varname) ||
-	        (EXPECTED(p->h == ZSTR_H(varname)) &&
-	         EXPECTED(p->key != NULL) &&
-	         EXPECTED(zend_string_equal_content(p->key, varname)))) {
+		    (EXPECTED(p->h == ZSTR_H(varname)) &&
+		     EXPECTED(p->key != NULL) &&
+		     EXPECTED(zend_string_equal_content(p->key, varname)))) {
 
 			value = (zval*)p; /* value = &p->val; */
 			goto check_indirect;
@@ -43522,7 +43593,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -44387,9 +44458,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
@@ -44425,7 +44496,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
 
 	if (IS_CV == IS_CONST ||
 	    (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -44473,9 +44544,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -44637,9 +44708,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -45950,7 +46021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HAN
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -46123,9 +46194,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVA
 
 	if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
 			function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC);
@@ -46676,7 +46747,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(Z
 				}
 			} else if (IS_CV == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -47215,9 +47286,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNU
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_UNUSED == IS_UNUSED) {
@@ -48475,7 +48546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(Z
 				}
 			} else if (IS_CV == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -48819,7 +48890,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) {
 				zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation");
@@ -49710,9 +49781,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_
 #endif
 
 	if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) {
-        if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
 			ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
-        }
+		}
 		ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 	} else {
 		if (IS_CV == IS_UNUSED) {
@@ -49748,7 +49819,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
 
 	if (IS_CV == IS_CONST ||
 	    (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) {
-	    do {
+		do {
 			if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) {
 				container = Z_REFVAL_P(container);
 				if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -49796,9 +49867,9 @@ fetch_obj_r_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_r_copy;
@@ -49960,9 +50031,9 @@ fetch_obj_is_fast_copy:
 							Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
 							if (EXPECTED(p->key == name) ||
-						        (EXPECTED(p->h == ZSTR_H(name)) &&
-						         EXPECTED(p->key != NULL) &&
-						         EXPECTED(zend_string_equal_content(p->key, name)))) {
+							    (EXPECTED(p->h == ZSTR_H(name)) &&
+							     EXPECTED(p->key != NULL) &&
+							     EXPECTED(zend_string_equal_content(p->key, name)))) {
 								retval = &p->val;
 								if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) {
 									goto fetch_obj_is_copy;
@@ -51346,7 +51417,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER
 			}
 		} else if (IS_CV != IS_CONST && IS_CV != IS_CV &&
 		    !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
-		    size_t len = ZSTR_LEN(op1_str);
+			size_t len = ZSTR_LEN(op1_str);
 
 			str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
 			memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
@@ -51519,9 +51590,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HA
 
 	if (IS_CV == IS_CONST &&
 	    EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) {
-	    fbc = CACHED_PTR(opline->result.num + sizeof(void*));
+		fbc = CACHED_PTR(opline->result.num + sizeof(void*));
 	} else {
-	    zend_object *orig_obj = obj;
+		zend_object *orig_obj = obj;
 
 		if (IS_CV == IS_CONST) {
 			function_name = EX_VAR(opline->op2.var);
@@ -52069,7 +52140,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_
 				}
 			} else if (IS_CV == IS_TMP_VAR) {
 				ZVAL_COPY_VALUE(&generator->value, value);
-            } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
+			} else if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) {
 				ZVAL_COPY(&generator->value, Z_REFVAL_P(value));
 
 			} else {
@@ -54397,6 +54468,8 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL,
 			(void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL,
 			(void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
+			(void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
+			(void*)&&ZEND_DO_ICALL_SPEC_OBSERVER_LABEL,
 			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
 			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
 			(void*)&&ZEND_DO_UCALL_SPEC_OBSERVER_LABEL,
@@ -55897,6 +55970,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_DO_ICALL_SPEC_RETVAL_USED)
 				ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_ICALL_SPEC_OBSERVER):
+				VM_TRACE(ZEND_DO_ICALL_SPEC_OBSERVER)
+				ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
 				VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED)
 				ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -62448,6 +62525,8 @@ void zend_vm_init(void)
 		ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER,
 		ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER,
 		ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
+		ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
+		ZEND_DO_ICALL_SPEC_OBSERVER_HANDLER,
 		ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
 		ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
 		ZEND_DO_UCALL_SPEC_OBSERVER_HANDLER,
@@ -63755,7 +63834,7 @@ void zend_vm_init(void)
 		1255,
 		1256 | SPEC_RULE_OP1,
 		1261 | SPEC_RULE_OP1,
-		3448,
+		3450,
 		1266 | SPEC_RULE_OP1,
 		1271 | SPEC_RULE_OP1,
 		1276 | SPEC_RULE_OP2,
@@ -63839,133 +63918,133 @@ void zend_vm_init(void)
 		2180,
 		2181,
 		2182 | SPEC_RULE_OP2,
-		2187 | SPEC_RULE_RETVAL,
-		2189 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
-		2193 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
-		2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2197 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2222 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2247 | SPEC_RULE_OP1,
-		2252,
-		2253 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2278,
-		2279 | SPEC_RULE_OP1,
-		2284,
-		2285,
+		2187 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		2191 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		2195 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2199 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2224 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2249 | SPEC_RULE_OP1,
+		2254,
+		2255 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2280,
+		2281 | SPEC_RULE_OP1,
 		2286,
 		2287,
 		2288,
 		2289,
 		2290,
-		2291 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2316,
-		2317,
+		2291,
+		2292,
+		2293 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		2318,
-		2319 | SPEC_RULE_OP1,
-		2324,
-		2325 | SPEC_RULE_ISSET,
-		2327 | SPEC_RULE_OP2,
-		2332,
-		2333 | SPEC_RULE_OP1,
-		2338 | SPEC_RULE_OBSERVER,
-		2340,
-		2341 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2366 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
-		2376,
-		2377,
+		2319,
+		2320,
+		2321 | SPEC_RULE_OP1,
+		2326,
+		2327 | SPEC_RULE_ISSET,
+		2329 | SPEC_RULE_OP2,
+		2334,
+		2335 | SPEC_RULE_OP1,
+		2340 | SPEC_RULE_OBSERVER,
+		2342,
+		2343 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2368 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
 		2378,
 		2379,
-		2380 | SPEC_RULE_OP1,
-		2385,
-		2386,
-		2387 | SPEC_RULE_OP1,
-		2392 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2417,
-		2418 | SPEC_RULE_OP1,
-		2423,
-		2424,
+		2380,
+		2381,
+		2382 | SPEC_RULE_OP1,
+		2387,
+		2388,
+		2389 | SPEC_RULE_OP1,
+		2394 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2419,
+		2420 | SPEC_RULE_OP1,
 		2425,
 		2426,
 		2427,
 		2428,
 		2429,
 		2430,
-		2431 | SPEC_RULE_OP1,
-		2436,
-		2437,
+		2431,
+		2432,
+		2433 | SPEC_RULE_OP1,
 		2438,
-		2439 | SPEC_RULE_OP2,
-		2444,
-		2445 | SPEC_RULE_OP1,
-		2450 | SPEC_RULE_OP1,
-		2455 | SPEC_RULE_OP1,
-		2460 | SPEC_RULE_OP1,
-		2465 | SPEC_RULE_OP1,
-		2470,
-		2471 | SPEC_RULE_OP1,
-		2476 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2501 | SPEC_RULE_OP1,
-		2506 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2531 | SPEC_RULE_OP1,
-		2536 | SPEC_RULE_OP1,
-		2541,
-		2542,
+		2439,
+		2440,
+		2441 | SPEC_RULE_OP2,
+		2446,
+		2447 | SPEC_RULE_OP1,
+		2452 | SPEC_RULE_OP1,
+		2457 | SPEC_RULE_OP1,
+		2462 | SPEC_RULE_OP1,
+		2467 | SPEC_RULE_OP1,
+		2472,
+		2473 | SPEC_RULE_OP1,
+		2478 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2503 | SPEC_RULE_OP1,
+		2508 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2533 | SPEC_RULE_OP1,
+		2538 | SPEC_RULE_OP1,
 		2543,
 		2544,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
-		3448,
+		2545,
+		2546,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
+		3450,
 	};
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
 	zend_opcode_handler_funcs = labels;
@@ -64138,7 +64217,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 = 2547 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2549 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -64146,7 +64225,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 = 2572 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2574 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -64154,7 +64233,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 = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2599 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -64165,17 +64244,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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2624 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2649 | 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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2674 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_MUL:
@@ -64186,17 +64265,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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2699 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2724 | 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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2749 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_IDENTICAL:
@@ -64207,14 +64286,14 @@ 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 = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2774 | 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 = 2847 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | 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 = 3072 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3074 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_IDENTICAL:
@@ -64225,14 +64304,14 @@ 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 = 2922 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2924 | 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 = 2997 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | 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 = 3077 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3079 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_EQUAL:
@@ -64243,12 +64322,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 = 2772 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2774 | 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 = 2847 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2849 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_EQUAL:
@@ -64259,12 +64338,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 = 2922 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2924 | 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 = 2997 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2999 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_SMALLER:
@@ -64272,12 +64351,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 = 3082 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3084 | 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 = 3157 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3159 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
@@ -64285,74 +64364,74 @@ 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 = 3232 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3234 | 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 = 3307 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3309 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_QM_ASSIGN:
 			if (op1_info == MAY_BE_LONG) {
-				spec = 3394 | SPEC_RULE_OP1;
+				spec = 3396 | SPEC_RULE_OP1;
 			} else if (op1_info == MAY_BE_DOUBLE) {
-				spec = 3399 | SPEC_RULE_OP1;
+				spec = 3401 | 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 = 3404 | SPEC_RULE_OP1;
+				spec = 3406 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_PRE_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3382 | SPEC_RULE_RETVAL;
-			} else if (op1_info == MAY_BE_LONG) {
 				spec = 3384 | SPEC_RULE_RETVAL;
+			} else if (op1_info == MAY_BE_LONG) {
+				spec = 3386 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_PRE_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3386 | SPEC_RULE_RETVAL;
-			} else if (op1_info == MAY_BE_LONG) {
 				spec = 3388 | SPEC_RULE_RETVAL;
+			} else if (op1_info == MAY_BE_LONG) {
+				spec = 3390 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_POST_INC:
-			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3390;
-			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3391;
-			}
-			break;
-		case ZEND_POST_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
 				spec = 3392;
 			} else if (op1_info == MAY_BE_LONG) {
 				spec = 3393;
 			}
 			break;
+		case ZEND_POST_DEC:
+			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
+				spec = 3394;
+			} else if (op1_info == MAY_BE_LONG) {
+				spec = 3395;
+			}
+			break;
 		case ZEND_JMP:
 			if (OP_JMP_ADDR(op, op->op1) > op) {
-				spec = 2546;
+				spec = 2548;
 			}
 			break;
 		case ZEND_RECV:
 			if (op->op2.num == MAY_BE_ANY) {
-				spec = 2545;
+				spec = 2547;
 			}
 			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 = 3444;
+				spec = 3446;
 			}
 			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 = 3439 | SPEC_RULE_OP1;
+				spec = 3441 | 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 = 3446 | SPEC_RULE_RETVAL;
+				spec = 3448 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_FETCH_DIM_R:
@@ -64360,17 +64439,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 = 3409 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 3411 | 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 = 3445;
+				spec = 3447;
 			}
 			break;
 		case ZEND_SEND_VAR:
 			if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3434 | SPEC_RULE_OP1;
+				spec = 3436 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_BW_OR:
diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 5f651ded1f3..d07c63d89f4 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1105,744 +1105,746 @@
 	_(2186, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
 	_(2187, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
 	_(2188, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
-	_(2189, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
-	_(2190, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
-	_(2191, ZEND_DO_UCALL_SPEC_OBSERVER) \
-	_(2192, ZEND_DO_UCALL_SPEC_OBSERVER) \
-	_(2193, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
-	_(2194, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
-	_(2195, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \
-	_(2196, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \
-	_(2207, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
-	_(2208, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
-	_(2212, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
-	_(2213, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
-	_(2217, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
-	_(2218, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2219, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2221, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
-	_(2232, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
-	_(2233, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2234, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2236, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
-	_(2237, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
-	_(2238, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
-	_(2242, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
-	_(2243, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2244, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2246, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
-	_(2247, ZEND_ECHO_SPEC_CONST) \
-	_(2248, ZEND_ECHO_SPEC_TMPVAR) \
-	_(2249, ZEND_ECHO_SPEC_TMPVAR) \
-	_(2251, ZEND_ECHO_SPEC_CV) \
-	_(2258, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-	_(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-	_(2261, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-	_(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-	_(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-	_(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-	_(2273, ZEND_INSTANCEOF_SPEC_CV_CONST) \
-	_(2275, ZEND_INSTANCEOF_SPEC_CV_VAR) \
-	_(2276, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
-	_(2278, ZEND_GENERATOR_CREATE_SPEC) \
-	_(2281, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
-	_(2283, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
-	_(2284, ZEND_DECLARE_FUNCTION_SPEC) \
-	_(2285, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \
-	_(2286, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
-	_(2287, ZEND_DECLARE_CLASS_SPEC_CONST) \
-	_(2288, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \
-	_(2289, ZEND_DECLARE_ANON_CLASS_SPEC) \
-	_(2290, ZEND_ADD_ARRAY_UNPACK_SPEC) \
-	_(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
-	_(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-	_(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-	_(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
-	_(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-	_(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-	_(2301, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-	_(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-	_(2306, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
-	_(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
-	_(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
-	_(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-	_(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-	_(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
-	_(2316, ZEND_HANDLE_EXCEPTION_SPEC) \
-	_(2317, ZEND_USER_OPCODE_SPEC) \
-	_(2318, ZEND_ASSERT_CHECK_SPEC) \
-	_(2319, ZEND_JMP_SET_SPEC_CONST) \
-	_(2320, ZEND_JMP_SET_SPEC_TMP) \
-	_(2321, ZEND_JMP_SET_SPEC_VAR) \
-	_(2323, ZEND_JMP_SET_SPEC_CV) \
-	_(2324, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
-	_(2325, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
-	_(2326, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
-	_(2327, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
-	_(2328, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-	_(2329, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-	_(2331, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
-	_(2332, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
-	_(2334, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
-	_(2335, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
-	_(2336, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
-	_(2337, ZEND_FETCH_CLASS_NAME_SPEC_CV) \
-	_(2338, ZEND_CALL_TRAMPOLINE_SPEC) \
-	_(2339, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \
-	_(2340, ZEND_DISCARD_EXCEPTION_SPEC) \
-	_(2341, ZEND_YIELD_SPEC_CONST_CONST) \
-	_(2342, ZEND_YIELD_SPEC_CONST_TMPVAR) \
-	_(2343, ZEND_YIELD_SPEC_CONST_TMPVAR) \
-	_(2344, ZEND_YIELD_SPEC_CONST_UNUSED) \
-	_(2345, ZEND_YIELD_SPEC_CONST_CV) \
-	_(2346, ZEND_YIELD_SPEC_TMP_CONST) \
-	_(2347, ZEND_YIELD_SPEC_TMP_TMPVAR) \
-	_(2348, ZEND_YIELD_SPEC_TMP_TMPVAR) \
-	_(2349, ZEND_YIELD_SPEC_TMP_UNUSED) \
-	_(2350, ZEND_YIELD_SPEC_TMP_CV) \
-	_(2351, ZEND_YIELD_SPEC_VAR_CONST) \
-	_(2352, ZEND_YIELD_SPEC_VAR_TMPVAR) \
-	_(2353, ZEND_YIELD_SPEC_VAR_TMPVAR) \
-	_(2354, ZEND_YIELD_SPEC_VAR_UNUSED) \
-	_(2355, ZEND_YIELD_SPEC_VAR_CV) \
-	_(2356, ZEND_YIELD_SPEC_UNUSED_CONST) \
-	_(2357, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
-	_(2358, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
-	_(2359, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
-	_(2360, ZEND_YIELD_SPEC_UNUSED_CV) \
-	_(2361, ZEND_YIELD_SPEC_CV_CONST) \
-	_(2362, ZEND_YIELD_SPEC_CV_TMPVAR) \
-	_(2363, ZEND_YIELD_SPEC_CV_TMPVAR) \
-	_(2364, ZEND_YIELD_SPEC_CV_UNUSED) \
-	_(2365, ZEND_YIELD_SPEC_CV_CV) \
-	_(2366, ZEND_GENERATOR_RETURN_SPEC_CONST) \
-	_(2367, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
-	_(2368, ZEND_GENERATOR_RETURN_SPEC_TMP) \
+	_(2189, ZEND_DO_ICALL_SPEC_OBSERVER) \
+	_(2190, ZEND_DO_ICALL_SPEC_OBSERVER) \
+	_(2191, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
+	_(2192, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
+	_(2193, ZEND_DO_UCALL_SPEC_OBSERVER) \
+	_(2194, ZEND_DO_UCALL_SPEC_OBSERVER) \
+	_(2195, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
+	_(2196, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
+	_(2197, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \
+	_(2198, ZEND_DO_FCALL_BY_NAME_SPEC_OBSERVER) \
+	_(2209, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
+	_(2210, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2211, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
+	_(2214, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
+	_(2215, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2216, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
+	_(2219, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
+	_(2220, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2221, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2223, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
+	_(2234, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
+	_(2235, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2236, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2238, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
+	_(2239, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
+	_(2240, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2241, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
+	_(2244, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
+	_(2245, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2246, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2248, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
+	_(2249, ZEND_ECHO_SPEC_CONST) \
+	_(2250, ZEND_ECHO_SPEC_TMPVAR) \
+	_(2251, ZEND_ECHO_SPEC_TMPVAR) \
+	_(2253, ZEND_ECHO_SPEC_CV) \
+	_(2260, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+	_(2262, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+	_(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+	_(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+	_(2267, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+	_(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+	_(2275, ZEND_INSTANCEOF_SPEC_CV_CONST) \
+	_(2277, ZEND_INSTANCEOF_SPEC_CV_VAR) \
+	_(2278, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
+	_(2280, ZEND_GENERATOR_CREATE_SPEC) \
+	_(2283, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
+	_(2285, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
+	_(2286, ZEND_DECLARE_FUNCTION_SPEC) \
+	_(2287, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST) \
+	_(2288, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
+	_(2289, ZEND_DECLARE_CLASS_SPEC_CONST) \
+	_(2290, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \
+	_(2291, ZEND_DECLARE_ANON_CLASS_SPEC) \
+	_(2292, ZEND_ADD_ARRAY_UNPACK_SPEC) \
+	_(2293, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
+	_(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+	_(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+	_(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
+	_(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
+	_(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2302, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
+	_(2303, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
+	_(2304, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2305, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
+	_(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
+	_(2309, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
+	_(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
+	_(2314, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+	_(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+	_(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
+	_(2318, ZEND_HANDLE_EXCEPTION_SPEC) \
+	_(2319, ZEND_USER_OPCODE_SPEC) \
+	_(2320, ZEND_ASSERT_CHECK_SPEC) \
+	_(2321, ZEND_JMP_SET_SPEC_CONST) \
+	_(2322, ZEND_JMP_SET_SPEC_TMP) \
+	_(2323, ZEND_JMP_SET_SPEC_VAR) \
+	_(2325, ZEND_JMP_SET_SPEC_CV) \
+	_(2326, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
+	_(2327, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
+	_(2328, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
+	_(2329, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
+	_(2330, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+	_(2331, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+	_(2333, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
+	_(2334, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
+	_(2336, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
+	_(2337, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
+	_(2338, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
+	_(2339, ZEND_FETCH_CLASS_NAME_SPEC_CV) \
+	_(2340, ZEND_CALL_TRAMPOLINE_SPEC) \
+	_(2341, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \
+	_(2342, ZEND_DISCARD_EXCEPTION_SPEC) \
+	_(2343, ZEND_YIELD_SPEC_CONST_CONST) \
+	_(2344, ZEND_YIELD_SPEC_CONST_TMPVAR) \
+	_(2345, ZEND_YIELD_SPEC_CONST_TMPVAR) \
+	_(2346, ZEND_YIELD_SPEC_CONST_UNUSED) \
+	_(2347, ZEND_YIELD_SPEC_CONST_CV) \
+	_(2348, ZEND_YIELD_SPEC_TMP_CONST) \
+	_(2349, ZEND_YIELD_SPEC_TMP_TMPVAR) \
+	_(2350, ZEND_YIELD_SPEC_TMP_TMPVAR) \
+	_(2351, ZEND_YIELD_SPEC_TMP_UNUSED) \
+	_(2352, ZEND_YIELD_SPEC_TMP_CV) \
+	_(2353, ZEND_YIELD_SPEC_VAR_CONST) \
+	_(2354, ZEND_YIELD_SPEC_VAR_TMPVAR) \
+	_(2355, ZEND_YIELD_SPEC_VAR_TMPVAR) \
+	_(2356, ZEND_YIELD_SPEC_VAR_UNUSED) \
+	_(2357, ZEND_YIELD_SPEC_VAR_CV) \
+	_(2358, ZEND_YIELD_SPEC_UNUSED_CONST) \
+	_(2359, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
+	_(2360, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
+	_(2361, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
+	_(2362, ZEND_YIELD_SPEC_UNUSED_CV) \
+	_(2363, ZEND_YIELD_SPEC_CV_CONST) \
+	_(2364, ZEND_YIELD_SPEC_CV_TMPVAR) \
+	_(2365, ZEND_YIELD_SPEC_CV_TMPVAR) \
+	_(2366, ZEND_YIELD_SPEC_CV_UNUSED) \
+	_(2367, ZEND_YIELD_SPEC_CV_CV) \
+	_(2368, ZEND_GENERATOR_RETURN_SPEC_CONST) \
 	_(2369, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
-	_(2370, ZEND_GENERATOR_RETURN_SPEC_VAR) \
+	_(2370, ZEND_GENERATOR_RETURN_SPEC_TMP) \
 	_(2371, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
-	_(2374, ZEND_GENERATOR_RETURN_SPEC_CV) \
-	_(2375, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
-	_(2376, ZEND_FAST_CALL_SPEC) \
-	_(2377, ZEND_FAST_RET_SPEC) \
-	_(2378, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
-	_(2379, ZEND_SEND_UNPACK_SPEC) \
-	_(2380, ZEND_YIELD_FROM_SPEC_CONST) \
-	_(2381, ZEND_YIELD_FROM_SPEC_TMPVAR) \
-	_(2382, ZEND_YIELD_FROM_SPEC_TMPVAR) \
-	_(2384, ZEND_YIELD_FROM_SPEC_CV) \
-	_(2385, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
-	_(2386, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
-	_(2387, ZEND_COALESCE_SPEC_CONST) \
-	_(2388, ZEND_COALESCE_SPEC_TMP) \
-	_(2389, ZEND_COALESCE_SPEC_VAR) \
-	_(2391, ZEND_COALESCE_SPEC_CV) \
-	_(2392, ZEND_SPACESHIP_SPEC_CONST_CONST) \
-	_(2393, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-	_(2394, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-	_(2396, ZEND_SPACESHIP_SPEC_CONST_CV) \
-	_(2397, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-	_(2398, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2399, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2401, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-	_(2402, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-	_(2403, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2406, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-	_(2412, ZEND_SPACESHIP_SPEC_CV_CONST) \
-	_(2413, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-	_(2414, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-	_(2416, ZEND_SPACESHIP_SPEC_CV_CV) \
-	_(2417, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2418, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
-	_(2421, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2423, ZEND_FETCH_STATIC_PROP_R_SPEC) \
-	_(2424, ZEND_FETCH_STATIC_PROP_W_SPEC) \
-	_(2425, ZEND_FETCH_STATIC_PROP_RW_SPEC) \
-	_(2426, ZEND_FETCH_STATIC_PROP_IS_SPEC) \
-	_(2427, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \
-	_(2428, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \
-	_(2429, ZEND_UNSET_STATIC_PROP_SPEC) \
-	_(2430, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \
-	_(2431, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
-	_(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
-	_(2434, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
-	_(2436, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
-	_(2437, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
-	_(2438, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
-	_(2439, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \
-	_(2442, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \
-	_(2444, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
-	_(2445, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
-	_(2446, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-	_(2447, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+	_(2372, ZEND_GENERATOR_RETURN_SPEC_VAR) \
+	_(2373, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
+	_(2376, ZEND_GENERATOR_RETURN_SPEC_CV) \
+	_(2377, ZEND_GENERATOR_RETURN_SPEC_OBSERVER) \
+	_(2378, ZEND_FAST_CALL_SPEC) \
+	_(2379, ZEND_FAST_RET_SPEC) \
+	_(2380, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
+	_(2381, ZEND_SEND_UNPACK_SPEC) \
+	_(2382, ZEND_YIELD_FROM_SPEC_CONST) \
+	_(2383, ZEND_YIELD_FROM_SPEC_TMPVAR) \
+	_(2384, ZEND_YIELD_FROM_SPEC_TMPVAR) \
+	_(2386, ZEND_YIELD_FROM_SPEC_CV) \
+	_(2387, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
+	_(2388, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
+	_(2389, ZEND_COALESCE_SPEC_CONST) \
+	_(2390, ZEND_COALESCE_SPEC_TMP) \
+	_(2391, ZEND_COALESCE_SPEC_VAR) \
+	_(2393, ZEND_COALESCE_SPEC_CV) \
+	_(2394, ZEND_SPACESHIP_SPEC_CONST_CONST) \
+	_(2395, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+	_(2396, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+	_(2398, ZEND_SPACESHIP_SPEC_CONST_CV) \
+	_(2399, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+	_(2400, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2401, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+	_(2404, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+	_(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2406, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2408, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+	_(2414, ZEND_SPACESHIP_SPEC_CV_CONST) \
+	_(2415, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+	_(2416, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+	_(2418, ZEND_SPACESHIP_SPEC_CV_CV) \
+	_(2419, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2420, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
+	_(2423, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2425, ZEND_FETCH_STATIC_PROP_R_SPEC) \
+	_(2426, ZEND_FETCH_STATIC_PROP_W_SPEC) \
+	_(2427, ZEND_FETCH_STATIC_PROP_RW_SPEC) \
+	_(2428, ZEND_FETCH_STATIC_PROP_IS_SPEC) \
+	_(2429, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \
+	_(2430, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \
+	_(2431, ZEND_UNSET_STATIC_PROP_SPEC) \
+	_(2432, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \
+	_(2433, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
+	_(2435, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
+	_(2436, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
+	_(2438, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
+	_(2439, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
+	_(2440, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
+	_(2441, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \
+	_(2444, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \
+	_(2446, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
+	_(2447, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
+	_(2448, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
 	_(2449, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-	_(2450, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
-	_(2451, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-	_(2452, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+	_(2451, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+	_(2452, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
+	_(2453, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
 	_(2454, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-	_(2455, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
-	_(2456, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
-	_(2457, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
-	_(2459, ZEND_IN_ARRAY_SPEC_CV_CONST) \
-	_(2460, ZEND_COUNT_SPEC_CONST_UNUSED) \
-	_(2461, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
-	_(2462, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
-	_(2464, ZEND_COUNT_SPEC_CV_UNUSED) \
-	_(2465, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
-	_(2466, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
-	_(2467, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
-	_(2468, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
-	_(2469, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
-	_(2470, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
-	_(2471, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
-	_(2472, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
-	_(2473, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
-	_(2475, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
-	_(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
-	_(2477, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-	_(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-	_(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
-	_(2481, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-	_(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-	_(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-	_(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-	_(2496, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
-	_(2497, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-	_(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-	_(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
-	_(2501, ZEND_MATCH_SPEC_CONST_CONST) \
-	_(2502, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
-	_(2503, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
+	_(2456, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+	_(2457, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
+	_(2458, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
+	_(2459, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
+	_(2461, ZEND_IN_ARRAY_SPEC_CV_CONST) \
+	_(2462, ZEND_COUNT_SPEC_CONST_UNUSED) \
+	_(2463, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
+	_(2464, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
+	_(2466, ZEND_COUNT_SPEC_CV_UNUSED) \
+	_(2467, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
+	_(2468, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
+	_(2469, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
+	_(2470, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
+	_(2471, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
+	_(2472, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
+	_(2473, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
+	_(2474, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
+	_(2475, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
+	_(2477, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
+	_(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
+	_(2479, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+	_(2480, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+	_(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
+	_(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+	_(2484, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2485, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+	_(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+	_(2489, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2490, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2492, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+	_(2498, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
+	_(2499, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+	_(2500, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+	_(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
+	_(2503, ZEND_MATCH_SPEC_CONST_CONST) \
+	_(2504, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
 	_(2505, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
-	_(2511, ZEND_CASE_STRICT_SPEC_TMP_CONST) \
-	_(2512, ZEND_CASE_STRICT_SPEC_TMP_TMP) \
-	_(2513, ZEND_CASE_STRICT_SPEC_TMP_VAR) \
-	_(2515, ZEND_CASE_STRICT_SPEC_TMP_CV) \
-	_(2516, ZEND_CASE_STRICT_SPEC_VAR_CONST) \
-	_(2517, ZEND_CASE_STRICT_SPEC_VAR_TMP) \
-	_(2518, ZEND_CASE_STRICT_SPEC_VAR_VAR) \
-	_(2520, ZEND_CASE_STRICT_SPEC_VAR_CV) \
-	_(2531, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \
-	_(2532, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
-	_(2533, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
+	_(2507, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
+	_(2513, ZEND_CASE_STRICT_SPEC_TMP_CONST) \
+	_(2514, ZEND_CASE_STRICT_SPEC_TMP_TMP) \
+	_(2515, ZEND_CASE_STRICT_SPEC_TMP_VAR) \
+	_(2517, ZEND_CASE_STRICT_SPEC_TMP_CV) \
+	_(2518, ZEND_CASE_STRICT_SPEC_VAR_CONST) \
+	_(2519, ZEND_CASE_STRICT_SPEC_VAR_TMP) \
+	_(2520, ZEND_CASE_STRICT_SPEC_VAR_VAR) \
+	_(2522, ZEND_CASE_STRICT_SPEC_VAR_CV) \
+	_(2533, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \
+	_(2534, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
 	_(2535, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
-	_(2536, ZEND_JMP_NULL_SPEC_CONST) \
-	_(2537, ZEND_JMP_NULL_SPEC_TMP) \
-	_(2538, ZEND_JMP_NULL_SPEC_VAR) \
-	_(2540, ZEND_JMP_NULL_SPEC_CV) \
-	_(2541, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2542, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \
-	_(2543, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \
-	_(2544, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \
-	_(2545, ZEND_RECV_NOTYPE_SPEC) \
-	_(2546, ZEND_JMP_FORWARD_SPEC) \
-	_(2552, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2553, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2537, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
+	_(2538, ZEND_JMP_NULL_SPEC_CONST) \
+	_(2539, ZEND_JMP_NULL_SPEC_TMP) \
+	_(2540, ZEND_JMP_NULL_SPEC_VAR) \
+	_(2542, ZEND_JMP_NULL_SPEC_CV) \
+	_(2543, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2544, ZEND_FETCH_GLOBALS_SPEC_UNUSED_UNUSED) \
+	_(2545, ZEND_VERIFY_NEVER_TYPE_SPEC_UNUSED_UNUSED) \
+	_(2546, ZEND_CALLABLE_CONVERT_SPEC_UNUSED_UNUSED) \
+	_(2547, ZEND_RECV_NOTYPE_SPEC) \
+	_(2548, ZEND_JMP_FORWARD_SPEC) \
+	_(2554, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2558, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2567, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2568, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2563, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2569, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2577, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2578, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2573, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2579, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
 	_(2583, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2592, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2593, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2594, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2588, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2594, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2602, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2603, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2598, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2604, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2608, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2617, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2618, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2613, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2619, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2623, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2624, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2623, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2625, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
 	_(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2627, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2628, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2633, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2642, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2643, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2638, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2644, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2648, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2649, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2648, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2650, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
 	_(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2652, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2653, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2653, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2654, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
 	_(2658, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2667, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2668, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2669, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2663, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2669, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2673, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2674, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2673, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2675, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
 	_(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2677, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2678, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2678, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2679, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2683, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2692, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2693, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2688, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2694, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2702, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2703, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2698, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2704, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2708, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2717, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2718, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2713, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2719, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2727, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2728, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2723, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2729, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
 	_(2733, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2742, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2743, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2744, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2738, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2744, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2752, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2753, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2748, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2754, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2758, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2767, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2768, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2763, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2769, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2787, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2788, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2799, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2800, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2837, 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) \
-	_(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) \
-	_(2862, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2863, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2874, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2875, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2912, 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) \
-	_(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) \
-	_(2937, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2938, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2949, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2950, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2987, 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) \
-	_(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) \
-	_(3012, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3013, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3024, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3025, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3062, 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) \
-	_(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_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3076, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3077, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3081, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3085, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3086, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3094, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3095, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3097, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3098, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3109, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3110, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_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) \
-	_(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3184, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3185, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_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) \
-	_(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3259, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3260, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_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) \
-	_(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3334, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3335, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_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_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3383, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3384, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3385, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3386, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3387, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3388, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3389, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3390, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3391, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3392, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3393, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3394, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
-	_(3395, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3396, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(2773, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2793, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2794, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2795, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2801, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2810, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2816, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2868, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2869, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2870, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2876, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2885, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2891, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2943, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2944, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2945, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2951, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2960, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2966, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3018, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3019, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3020, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3026, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3035, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3041, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3074, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3078, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3079, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3083, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3087, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3088, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3089, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3090, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3096, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3098, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3103, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3104, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3105, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3111, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3120, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3126, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3171, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3178, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3179, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3180, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3186, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3246, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3253, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3254, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3255, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3261, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3321, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3328, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3329, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3330, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3336, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3384, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3385, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3386, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3387, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3388, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3390, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3391, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3392, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3393, ZEND_POST_INC_LONG_SPEC_CV) \
+	_(3394, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3395, ZEND_POST_DEC_LONG_SPEC_CV) \
+	_(3396, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
+	_(3397, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
 	_(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3399, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-	_(3400, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3401, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3400, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3401, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+	_(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
 	_(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3404, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-	_(3405, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3406, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3405, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3406, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+	_(3407, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
 	_(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3410, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3411, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3410, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3412, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
 	_(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3414, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3415, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
 	_(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
 	_(3420, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
 	_(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3429, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-	_(3430, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3425, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3431, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+	_(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
 	_(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3436, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-	_(3438, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-	_(3441, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
-	_(3443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
-	_(3444, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-	_(3445, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-	_(3446, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-	_(3447, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-	_(3447+1, ZEND_NULL)
+	_(3435, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3438, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+	_(3440, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+	_(3443, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
+	_(3445, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
+	_(3446, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+	_(3447, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+	_(3448, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+	_(3449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+	_(3449+1, ZEND_NULL)
diff --git a/ext/opcache/jit/zend_jit_arm64.dasc b/ext/opcache/jit/zend_jit_arm64.dasc
index d0ea3b06b2d..cd8f3ab1238 100644
--- a/ext/opcache/jit/zend_jit_arm64.dasc
+++ b/ext/opcache/jit/zend_jit_arm64.dasc
@@ -9527,13 +9527,19 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
 			}
 		}
 
+		|	// EG(current_execute_data) = execute_data;
+		|	MEM_STORE_64_ZTS str, RX, executor_globals, current_execute_data, REG1
+
+		if (ZEND_OBSERVER_ENABLED) {
+			|	mov FCARG1x, RX
+			|	EXT_CALL zend_observer_fcall_begin, REG0
+			|	ldr REG0, EX:RX->func // reload
+		}
+
 		|	// ZVAL_NULL(EX_VAR(opline->result.var));
 		|	LOAD_ZVAL_ADDR FCARG2x, res_addr
 		|	SET_Z_TYPE_INFO FCARG2x, IS_NULL, TMP1w
 
-		|	// EG(current_execute_data) = execute_data;
-		|	MEM_STORE_64_ZTS str, RX, executor_globals, current_execute_data, REG1
-
 		zend_jit_reset_last_valid_opline();
 
 		|	// fbc->internal_function.handler(call, ret);
@@ -9545,6 +9551,12 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
 			|	blr TMP1
 		}
 
+		if (ZEND_OBSERVER_ENABLED) {
+			|	LOAD_ZVAL_ADDR FCARG2x, res_addr
+			|	mov FCARG1x, RX
+			|	EXT_CALL zend_observer_fcall_end, REG0
+		}
+
 		|	// EG(current_execute_data) = execute_data;
 		|	MEM_STORE_64_ZTS str, FP, executor_globals, current_execute_data, REG0
 
diff --git a/ext/opcache/jit/zend_jit_x86.dasc b/ext/opcache/jit/zend_jit_x86.dasc
index e853398c962..f5688e88546 100644
--- a/ext/opcache/jit/zend_jit_x86.dasc
+++ b/ext/opcache/jit/zend_jit_x86.dasc
@@ -10231,13 +10231,19 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
 			}
 		}
 
+		|	// EG(current_execute_data) = execute_data;
+		|	MEM_STORE_ZTS aword, executor_globals, current_execute_data, RX, r1
+
+		if (ZEND_OBSERVER_ENABLED) {
+			|	mov FCARG1a, RX
+			|	EXT_CALL zend_observer_fcall_begin, r0
+			|	mov r0, EX:RX->func // reload
+		}
+
 		|	// ZVAL_NULL(EX_VAR(opline->result.var));
 		|	LOAD_ZVAL_ADDR FCARG2a, res_addr
 		|	SET_Z_TYPE_INFO FCARG2a, IS_NULL
 
-		|	// EG(current_execute_data) = execute_data;
-		|	MEM_STORE_ZTS aword, executor_globals, current_execute_data, RX, r1
-
 		zend_jit_reset_last_valid_opline();
 
 		|	// fbc->internal_function.handler(call, ret);
@@ -10248,6 +10254,12 @@ static int zend_jit_do_fcall(dasm_State **Dst, const zend_op *opline, const zend
 			|	call aword [r0 + offsetof(zend_internal_function, handler)]
 		}
 
+		if (ZEND_OBSERVER_ENABLED) {
+			|	LOAD_ZVAL_ADDR FCARG2a, res_addr
+			|	mov FCARG1a, RX
+			|	EXT_CALL zend_observer_fcall_end, r0
+		}
+
 		|	// EG(current_execute_data) = execute_data;
 		|	MEM_STORE_ZTS aword, executor_globals, current_execute_data, FP, r0
 
diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 3a10bf05f53..260b40daf71 100644
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -1245,6 +1245,7 @@ bool pdo_hash_methods(pdo_dbh_object_t *dbh_obj, int kind)
 		func.function_name = zend_string_init(funcs->fname, strlen(funcs->fname), dbh->is_persistent);
 		func.scope = dbh_obj->std.ce;
 		func.prototype = NULL;
+		ZEND_MAP_PTR(func.run_time_cache) = NULL;
 		if (funcs->flags) {
 			func.fn_flags = funcs->flags | ZEND_ACC_NEVER_CACHE;
 		} else {
diff --git a/ext/zend_test/observer.c b/ext/zend_test/observer.c
index b64190bb23f..b324421c36c 100644
--- a/ext/zend_test/observer.c
+++ b/ext/zend_test/observer.c
@@ -264,8 +264,8 @@ static ZEND_INI_MH(zend_test_observer_OnUpdateCommaList)
 	if (stage != PHP_INI_STAGE_STARTUP && stage != PHP_INI_STAGE_ACTIVATE && stage != PHP_INI_STAGE_DEACTIVATE && stage != PHP_INI_STAGE_SHUTDOWN) {
 		ZEND_HASH_FOREACH_STR_KEY(*p, funcname) {
 			if ((func = zend_hash_find_ptr(EG(function_table), funcname))) {
-				zend_observer_remove_begin_handler(&func->op_array, observer_begin);
-				zend_observer_remove_end_handler(&func->op_array, observer_end);
+				zend_observer_remove_begin_handler(func, observer_begin);
+				zend_observer_remove_end_handler(func, observer_end);
 			}
 		} ZEND_HASH_FOREACH_END();
 	}
@@ -280,8 +280,8 @@ static ZEND_INI_MH(zend_test_observer_OnUpdateCommaList)
 		if (stage != PHP_INI_STAGE_STARTUP && stage != PHP_INI_STAGE_ACTIVATE && stage != PHP_INI_STAGE_DEACTIVATE && stage != PHP_INI_STAGE_SHUTDOWN) {
 			ZEND_HASH_FOREACH_STR_KEY(*p, funcname) {
 				if ((func = zend_hash_find_ptr(EG(function_table), funcname))) {
-					zend_observer_add_begin_handler(&func->op_array, observer_begin);
-					zend_observer_add_end_handler(&func->op_array, observer_end);
+					zend_observer_add_begin_handler(func, observer_begin);
+					zend_observer_add_end_handler(func, observer_end);
 				}
 			} ZEND_HASH_FOREACH_END();
 		}
diff --git a/ext/zend_test/tests/observer_backtrace_01.phpt b/ext/zend_test/tests/observer_backtrace_01.phpt
index 875a04c395f..7f021bf4025 100644
--- a/ext/zend_test/tests/observer_backtrace_01.phpt
+++ b/ext/zend_test/tests/observer_backtrace_01.phpt
@@ -48,38 +48,32 @@ var_dump(foo());
       {main} %s%eobserver_backtrace_%d.php
   -->
   <foo>
-    <!-- init gen() -->
+    <!-- init Generator::current() -->
     <!--
-        gen()
         Generator::current()
         foo()
         {main} %s%eobserver_backtrace_%d.php
     -->
-    <gen>
-      <!-- init TestClass::foo() -->
+    <Generator::current>
+      <!-- init gen() -->
       <!--
-          TestClass::foo()
           gen()
           Generator::current()
           foo()
           {main} %s%eobserver_backtrace_%d.php
       -->
-      <TestClass::foo>
-        <!-- init TestClass::{closure}() -->
+      <gen>
+        <!-- init TestClass::foo() -->
         <!--
-            TestClass::{closure}()
-            array_map()
             TestClass::foo()
             gen()
             Generator::current()
             foo()
             {main} %s%eobserver_backtrace_%d.php
         -->
-        <TestClass::{closure}>
-          <!-- init TestClass::bar() -->
+        <TestClass::foo>
+          <!-- init array_map() -->
           <!--
-              TestClass::bar()
-              TestClass::{closure}()
               array_map()
               TestClass::foo()
               gen()
@@ -87,20 +81,52 @@ var_dump(foo());
               foo()
               {main} %s%eobserver_backtrace_%d.php
           -->
-          <TestClass::bar>
-          </TestClass::bar>
-        </TestClass::{closure}>
-        <TestClass::{closure}>
-          <TestClass::bar>
-          </TestClass::bar>
-        </TestClass::{closure}>
-      </TestClass::foo>
-    </gen>
+          <array_map>
+            <!-- init TestClass::{closure}() -->
+            <!--
+                TestClass::{closure}()
+                array_map()
+                TestClass::foo()
+                gen()
+                Generator::current()
+                foo()
+                {main} %s%eobserver_backtrace_%d.php
+            -->
+            <TestClass::{closure}>
+              <!-- init TestClass::bar() -->
+              <!--
+                  TestClass::bar()
+                  TestClass::{closure}()
+                  array_map()
+                  TestClass::foo()
+                  gen()
+                  Generator::current()
+                  foo()
+                  {main} %s%eobserver_backtrace_%d.php
+              -->
+              <TestClass::bar>
+              </TestClass::bar>
+            </TestClass::{closure}>
+            <TestClass::{closure}>
+              <TestClass::bar>
+              </TestClass::bar>
+            </TestClass::{closure}>
+          </array_map>
+        </TestClass::foo>
+      </gen>
+    </Generator::current>
   </foo>
+  <!-- init var_dump() -->
+  <!--
+      var_dump()
+      {main} %s%eobserver_backtrace_%d.php
+  -->
+  <var_dump>
 array(2) {
   [0]=>
   int(42)
   [1]=>
   int(1337)
 }
+  </var_dump>
 </file '%s%eobserver_backtrace_%d.php'>
diff --git a/ext/zend_test/tests/observer_basic_01.phpt b/ext/zend_test/tests/observer_basic_01.phpt
index 369339fb77c..b208ae2341e 100644
--- a/ext/zend_test/tests/observer_basic_01.phpt
+++ b/ext/zend_test/tests/observer_basic_01.phpt
@@ -26,30 +26,44 @@ foo();
 echo 'DONE' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_basic_01.php' -->
-<file '%s%eobserver_basic_01.php'>
+<!-- init '%s%eobserver_basic_%d.php' -->
+<file '%s%eobserver_basic_%d.php'>
   <!-- init foo() -->
   <foo>
 Foo
     <!-- init bar() -->
     <bar>
 Bar
+      <!-- init array_sum() -->
+      <array_sum>
+      </array_sum>
+      <!-- init var_dump() -->
+      <var_dump>
 int(6)
+      </var_dump>
     </bar>
   </foo>
   <foo>
 Foo
     <bar>
 Bar
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(6)
+      </var_dump>
     </bar>
   </foo>
   <foo>
 Foo
     <bar>
 Bar
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(6)
+      </var_dump>
     </bar>
   </foo>
 DONE
-</file '%s%eobserver_basic_01.php'>
+</file '%s%eobserver_basic_%d.php'>
diff --git a/ext/zend_test/tests/observer_basic_02.phpt b/ext/zend_test/tests/observer_basic_02.phpt
index adbdc781815..ac61a8b18e7 100644
--- a/ext/zend_test/tests/observer_basic_02.phpt
+++ b/ext/zend_test/tests/observer_basic_02.phpt
@@ -30,30 +30,44 @@ $test->foo();
 echo 'DONE' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_basic_02.php' -->
-<file '%s%eobserver_basic_02.php'>
+<!-- init '%s%eobserver_basic_%d.php' -->
+<file '%s%eobserver_basic_%d.php'>
   <!-- init TestClass::foo() -->
   <TestClass::foo>
 Foo
     <!-- init TestClass::bar() -->
     <TestClass::bar>
 Bar
+      <!-- init array_sum() -->
+      <array_sum>
+      </array_sum>
+      <!-- init var_dump() -->
+      <var_dump>
 int(6)
+      </var_dump>
     </TestClass::bar>
   </TestClass::foo>
   <TestClass::foo>
 Foo
     <TestClass::bar>
 Bar
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(6)
+      </var_dump>
     </TestClass::bar>
   </TestClass::foo>
   <TestClass::foo>
 Foo
     <TestClass::bar>
 Bar
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(6)
+      </var_dump>
     </TestClass::bar>
   </TestClass::foo>
 DONE
-</file '%s%eobserver_basic_02.php'>
+</file '%s%eobserver_basic_%d.php'>
diff --git a/ext/zend_test/tests/observer_basic_06.phpt b/ext/zend_test/tests/observer_basic_06.phpt
index a8a183ba7ae..d27c340db19 100644
--- a/ext/zend_test/tests/observer_basic_06.phpt
+++ b/ext/zend_test/tests/observer_basic_06.phpt
@@ -34,6 +34,7 @@ Foo
 </foo>
 <!-- init bar() -->
 Bar
+<!-- init ini_set() -->
 Foo
 <bar>
 Bar
diff --git a/ext/zend_test/tests/observer_bug81430_1.phpt b/ext/zend_test/tests/observer_bug81430_1.phpt
index cac53ef70cb..34ac119e544 100644
--- a/ext/zend_test/tests/observer_bug81430_1.phpt
+++ b/ext/zend_test/tests/observer_bug81430_1.phpt
@@ -25,7 +25,16 @@ call_user_func([$r->getAttributes(A::class)[0], 'newInstance']);
 --EXPECTF--
 <!-- init '%s' -->
 <file '%s'>
-  <!-- init A::__construct() -->
-  <A::__construct>
-  </A::__construct>
-</file '%s'>
+  <!-- init ReflectionFunction::__construct() -->
+  <ReflectionFunction::__construct>
+  </ReflectionFunction::__construct>
+  <!-- init ReflectionFunctionAbstract::getAttributes() -->
+  <ReflectionFunctionAbstract::getAttributes>
+  </ReflectionFunctionAbstract::getAttributes>
+  <!-- init ReflectionAttribute::newInstance() -->
+  <ReflectionAttribute::newInstance>
+    <!-- init A::__construct() -->
+    <A::__construct>
+    </A::__construct>
+  </ReflectionAttribute::newInstance>
+</file '%s'>
\ No newline at end of file
diff --git a/ext/zend_test/tests/observer_bug81430_2.phpt b/ext/zend_test/tests/observer_bug81430_2.phpt
index 4d56248a80f..9bc919da896 100644
--- a/ext/zend_test/tests/observer_bug81430_2.phpt
+++ b/ext/zend_test/tests/observer_bug81430_2.phpt
@@ -25,9 +25,24 @@ call_user_func([$r->getAttributes(A::class)[0], 'newInstance']);
 --EXPECTF--
 <!-- init '%s' -->
 <file '%s'>
-  <!-- init A::__construct() -->
-  <A::__construct>
+  <!-- init ReflectionFunction::__construct() -->
+  <ReflectionFunction::__construct>
+  </ReflectionFunction::__construct>
+  <!-- init ReflectionFunctionAbstract::getAttributes() -->
+  <ReflectionFunctionAbstract::getAttributes>
+  </ReflectionFunctionAbstract::getAttributes>
+  <!-- init ReflectionAttribute::newInstance() -->
+  <ReflectionAttribute::newInstance>
+    <!-- init A::__construct() -->
+    <A::__construct>
+      <!-- init array_map() -->
+      <array_map>
+        <!-- init str_repeat() -->
+        <str_repeat>
 
 Fatal error: Allowed memory size of %d bytes exhausted %s in %s on line %d
-  </A::__construct>
+        </str_repeat>
+      </array_map>
+    </A::__construct>
+  </ReflectionAttribute::newInstance>
 </file '%s'>
diff --git a/ext/zend_test/tests/observer_bug81435.phpt b/ext/zend_test/tests/observer_bug81435.phpt
index 2b78c509931..b2a36df0a4b 100644
--- a/ext/zend_test/tests/observer_bug81435.phpt
+++ b/ext/zend_test/tests/observer_bug81435.phpt
@@ -42,6 +42,8 @@ a();
   <d>
   </d>
   <!-- init bailout() -->
+  <!-- init array_map() -->
+  <!-- init str_repeat() -->
 
 Fatal error: Allowed memory size of 20971520 bytes exhausted %s in %s on line %d
 </a>
diff --git a/ext/zend_test/tests/observer_call_user_func_03.phpt b/ext/zend_test/tests/observer_call_user_func_03.phpt
index 827730111f6..4eef414747d 100644
--- a/ext/zend_test/tests/observer_call_user_func_03.phpt
+++ b/ext/zend_test/tests/observer_call_user_func_03.phpt
@@ -26,14 +26,19 @@ namespace Test {
 }
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_call_user_func_%d.php' -->
-<file '%s%eobserver_call_user_func_%d.php'>
-  <!-- init Test\MyClass::myMethod() -->
-  <Test\MyClass::myMethod>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init call_user_func() -->
+  <call_user_func>
+    <!-- init Test\MyClass::myMethod() -->
+    <Test\MyClass::myMethod>
 MyClass::myMethod called
-  </Test\MyClass::myMethod>
-  <!-- init Test\my_function() -->
-  <Test\my_function>
+    </Test\MyClass::myMethod>
+  </call_user_func>
+  <call_user_func>
+    <!-- init Test\my_function() -->
+    <Test\my_function>
 my_function called
-  </Test\my_function>
-</file '%s%eobserver_call_user_func_%d.php'>
+    </Test\my_function>
+  </call_user_func>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_call_user_func_04.phpt b/ext/zend_test/tests/observer_call_user_func_04.phpt
index 7f516002aef..97921a70df7 100644
--- a/ext/zend_test/tests/observer_call_user_func_04.phpt
+++ b/ext/zend_test/tests/observer_call_user_func_04.phpt
@@ -26,14 +26,19 @@ namespace Test {
 }
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_call_user_func_%d.php' -->
-<file '%s%eobserver_call_user_func_%d.php'>
-  <!-- init Test\MyClass::myMethod() -->
-  <Test\MyClass::myMethod>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init call_user_func_array() -->
+  <call_user_func_array>
+    <!-- init Test\MyClass::myMethod() -->
+    <Test\MyClass::myMethod>
 MyClass::myMethod called
-  </Test\MyClass::myMethod>
-  <!-- init Test\my_function() -->
-  <Test\my_function>
+    </Test\MyClass::myMethod>
+  </call_user_func_array>
+  <call_user_func_array>
+    <!-- init Test\my_function() -->
+    <Test\my_function>
 my_function called
-  </Test\my_function>
-</file '%s%eobserver_call_user_func_%d.php'>
+    </Test\my_function>
+  </call_user_func_array>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_closure_01.phpt b/ext/zend_test/tests/observer_closure_01.phpt
index c10b170337b..2778d277225 100644
--- a/ext/zend_test/tests/observer_closure_01.phpt
+++ b/ext/zend_test/tests/observer_closure_01.phpt
@@ -23,27 +23,41 @@ $foo($bar);
 echo 'DONE' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_closure_%d.php' -->
-<file '%s%eobserver_closure_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init {closure}() -->
   <{closure}>
 Answer
     <!-- init {closure}() -->
     <{closure}>
+      <!-- init array_sum() -->
+      <array_sum>
+      </array_sum>
+      <!-- init var_dump() -->
+      <var_dump>
 int(42)
+      </var_dump>
     </{closure}>
   </{closure}>
   <{closure}>
 Answer
     <{closure}>
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(42)
+      </var_dump>
     </{closure}>
   </{closure}>
   <{closure}>
 Answer
     <{closure}>
+      <array_sum>
+      </array_sum>
+      <var_dump>
 int(42)
+      </var_dump>
     </{closure}>
   </{closure}>
 DONE
-</file '%s%eobserver_closure_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_closure_02.phpt b/ext/zend_test/tests/observer_closure_02.phpt
index e9724405647..ce75ccd12e0 100644
--- a/ext/zend_test/tests/observer_closure_02.phpt
+++ b/ext/zend_test/tests/observer_closure_02.phpt
@@ -22,11 +22,14 @@ $closure();
 echo 'DONE' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_closure_%d.php' -->
-<file '%s%eobserver_closure_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init Closure::fromCallable() -->
+  <Closure::fromCallable>
+  </Closure::fromCallable>
   <!-- init Foo::bar() -->
   <Foo::bar>
 Called as fake closure.
   </Foo::bar>
 DONE
-</file '%s%eobserver_closure_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_error_01.phpt b/ext/zend_test/tests/observer_error_01.phpt
index 534e484c8a0..870070046ed 100644
--- a/ext/zend_test/tests/observer_error_01.phpt
+++ b/ext/zend_test/tests/observer_error_01.phpt
@@ -19,11 +19,14 @@ foo();
 echo 'You should not see this.';
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_error_%d.php' -->
-<file '%s%eobserver_error_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init foo() -->
   <foo>
+    <!-- init str_repeat() -->
+    <str_repeat>
 
 Fatal error: Allowed memory size of 2097152 bytes exhausted%s(tried to allocate %d bytes) in %s on line %d
+    </str_repeat:NULL>
   </foo:NULL>
 </file '%s%eobserver_error_%d.php'>
diff --git a/ext/zend_test/tests/observer_error_02.phpt b/ext/zend_test/tests/observer_error_02.phpt
index 426c345e750..58b2d5ea80e 100644
--- a/ext/zend_test/tests/observer_error_02.phpt
+++ b/ext/zend_test/tests/observer_error_02.phpt
@@ -18,11 +18,14 @@ foo();
 echo 'You should not see this.';
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_error_%d.php' -->
-<file '%s%eobserver_error_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init foo() -->
   <foo>
+    <!-- init trigger_error() -->
+    <trigger_error>
 
 Fatal error: Foo error in %s on line %d
+    </trigger_error:NULL>
   </foo:NULL>
-</file '%s%eobserver_error_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_error_04.phpt b/ext/zend_test/tests/observer_error_04.phpt
index da0bc4b6c94..f8c68ebeeda 100644
--- a/ext/zend_test/tests/observer_error_04.phpt
+++ b/ext/zend_test/tests/observer_error_04.phpt
@@ -36,10 +36,18 @@ echo 'Done.' . PHP_EOL;
   <main>
     <!-- init foo() -->
     <foo>
+      <!-- init SoapClient::__construct() -->
+      <SoapClient::__construct>
+        <!-- Exception: SoapFault -->
+      </SoapClient::__construct:NULL>
       <!-- Exception: SoapFault -->
     </foo:NULL>
     <!-- Exception: SoapFault -->
   </main:NULL>
+  <!-- init Exception::getMessage() -->
+  <Exception::getMessage>
+  </Exception::getMessage:'SOAP-ERROR: Parsing WSDL: Couldn\'t load from \'foo\' : failed to load external entity "foo"
+'>
 SOAP-ERROR: Parsing WSDL: Couldn't load from 'foo' : failed to load external entity "foo"
 
 Done.
diff --git a/ext/zend_test/tests/observer_error_05.phpt b/ext/zend_test/tests/observer_error_05.phpt
index 58a34096604..9debfc2b0ad 100644
--- a/ext/zend_test/tests/observer_error_05.phpt
+++ b/ext/zend_test/tests/observer_error_05.phpt
@@ -22,14 +22,20 @@ foo();
 echo 'You should not see this.';
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_error_%d.php' -->
-<file '%s%eobserver_error_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init set_error_handler() -->
+  <set_error_handler>
+  </set_error_handler:NULL>
   <!-- init foo() -->
   <foo>
     <!-- init {closure}() -->
     <{closure}>
+      <!-- init trigger_error() -->
+      <trigger_error>
 
 Fatal error: Foo error in %s on line %d
+      </trigger_error:NULL>
     </{closure}:NULL>
   </foo:NULL>
-</file '%s%eobserver_error_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_exception_01.phpt b/ext/zend_test/tests/observer_exception_01.phpt
index 19e90e0ac62..2c296991e40 100644
--- a/ext/zend_test/tests/observer_exception_01.phpt
+++ b/ext/zend_test/tests/observer_exception_01.phpt
@@ -23,8 +23,8 @@ foo();
 echo 'You should not see this' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_exception_%d.php' -->
-<file '%s%eobserver_exception_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init foo() -->
   <foo>
 Call #0
@@ -34,10 +34,19 @@ Call #1
   </foo>
   <foo>
 Call #2
+    <!-- init Exception::__construct() -->
+    <Exception::__construct>
+    </Exception::__construct>
     <!-- Exception: RuntimeException -->
   </foo>
   <!-- Exception: RuntimeException -->
-</file '%s%eobserver_exception_%d.php'>
+</file '%s'>
+<!-- init Exception::__toString() -->
+<Exception::__toString>
+  <!-- init Exception::getTraceAsString() -->
+  <Exception::getTraceAsString>
+  </Exception::getTraceAsString>
+</Exception::__toString>
 
 Fatal error: Uncaught RuntimeException: Third time is a charm in %s%eobserver_exception_%d.php:%d
 Stack trace:
diff --git a/ext/zend_test/tests/observer_fiber_01.phpt b/ext/zend_test/tests/observer_fiber_01.phpt
index bd657310160..a70df36b0bb 100644
--- a/ext/zend_test/tests/observer_fiber_01.phpt
+++ b/ext/zend_test/tests/observer_fiber_01.phpt
@@ -19,13 +19,17 @@ $fiber->resume();
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_01.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- alloc: %s -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
+<!-- init Fiber::resume() -->
 <!-- switching from fiber %s to %s -->
 <resume '%s'>
 <!-- switching from fiber %s to %s -->
diff --git a/ext/zend_test/tests/observer_fiber_02.phpt b/ext/zend_test/tests/observer_fiber_02.phpt
index 6e420ef0ea6..34fe42c10f2 100644
--- a/ext/zend_test/tests/observer_fiber_02.phpt
+++ b/ext/zend_test/tests/observer_fiber_02.phpt
@@ -16,10 +16,13 @@ $fiber->start();
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_02.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
 <!-- switching from fiber %s to %s -->
diff --git a/ext/zend_test/tests/observer_fiber_03.phpt b/ext/zend_test/tests/observer_fiber_03.phpt
index 67699c25ae8..d55e8d9e84c 100644
--- a/ext/zend_test/tests/observer_fiber_03.phpt
+++ b/ext/zend_test/tests/observer_fiber_03.phpt
@@ -39,14 +39,19 @@ $fiber->resume();
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_03.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
+<!-- init Fiber::resume() -->
 <!-- switching from fiber %s to %s -->
 <resume '%s'>
+<!-- init var_dump() -->
 int(1)
 <!-- switching from fiber %s to %s -->
 <init '%s'>
diff --git a/ext/zend_test/tests/observer_fiber_04.phpt b/ext/zend_test/tests/observer_fiber_04.phpt
index 3a72132f5b5..29e1b2d0868 100644
--- a/ext/zend_test/tests/observer_fiber_04.phpt
+++ b/ext/zend_test/tests/observer_fiber_04.phpt
@@ -26,12 +26,16 @@ $fiber->resume();
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_04.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
+<!-- init Fiber::resume() -->
 <!-- switching from fiber %s to %s -->
 <resume '%s'>
 <!-- switching from fiber %s to %s -->
diff --git a/ext/zend_test/tests/observer_fiber_05.phpt b/ext/zend_test/tests/observer_fiber_05.phpt
index 87ba3a856ca..ce589033f97 100644
--- a/ext/zend_test/tests/observer_fiber_05.phpt
+++ b/ext/zend_test/tests/observer_fiber_05.phpt
@@ -25,12 +25,16 @@ $fiber->resume();
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_05.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
+<!-- init Fiber::resume() -->
 <!-- switching from fiber %s to %s -->
 <resume '%s'>
 <!-- switching from fiber %s to %s -->
diff --git a/ext/zend_test/tests/observer_fiber_06.phpt b/ext/zend_test/tests/observer_fiber_06.phpt
index 5a80a8efc1c..7176336c5ff 100644
--- a/ext/zend_test/tests/observer_fiber_06.phpt
+++ b/ext/zend_test/tests/observer_fiber_06.phpt
@@ -22,12 +22,17 @@ try {
 
 ?>
 --EXPECTF--
-<!-- init '%sobserver_fiber_06.php' -->
+<!-- init '%s' -->
+<!-- init Fiber::__construct() -->
+<!-- init Fiber::start() -->
 <!-- switching from fiber %s to %s -->
 <init '%s'>
 <!-- init {closure}() -->
+<!-- init Fiber::suspend() -->
 <!-- switching from fiber %s to %s -->
 <suspend '%s'>
+<!-- init Exception::__construct() -->
+<!-- init Fiber::throw() -->
 <!-- switching from fiber %s to %s -->
 <resume '%s'>
 <!-- switching from fiber %s to %s -->
diff --git a/ext/zend_test/tests/observer_generator_02.phpt b/ext/zend_test/tests/observer_generator_02.phpt
index 289cfa1f954..08c0992e442 100644
--- a/ext/zend_test/tests/observer_generator_02.phpt
+++ b/ext/zend_test/tests/observer_generator_02.phpt
@@ -28,8 +28,8 @@ function doSomething() {
 echo doSomething() . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_generator_%d.php' -->
-<file '%s%eobserver_generator_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init doSomething() -->
   <doSomething>
     <!-- init getResults() -->
@@ -44,7 +44,10 @@ echo doSomething() . PHP_EOL;
 12
     <getResults>
     </getResults:1337>
+    <!-- init Generator::getReturn() -->
+    <Generator::getReturn>
+    </Generator::getReturn:1337>
 1337
   </doSomething:'Done'>
 Done
-</file '%s%eobserver_generator_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_generator_04.phpt b/ext/zend_test/tests/observer_generator_04.phpt
index 46fb272162e..00cc999ace6 100644
--- a/ext/zend_test/tests/observer_generator_04.phpt
+++ b/ext/zend_test/tests/observer_generator_04.phpt
@@ -33,32 +33,87 @@ function doSomething() {
 echo doSomething() . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_generator_%d.php' -->
-<file '%s%eobserver_generator_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init doSomething() -->
   <doSomething>
-    <!-- init fooResults() -->
-    <fooResults>
+    <!-- init Generator::current() -->
+    <Generator::current>
+      <!-- init fooResults() -->
+      <fooResults>
 Starting generator
-    </fooResults:0>
+      </fooResults:0>
+    </Generator::current:0>
+    <Generator::current>
+    </Generator::current:0>
 0
-    <fooResults>
-    </fooResults:1>
+    <Generator::current>
+    </Generator::current:0>
+    <!-- init Generator::next() -->
+    <Generator::next>
+      <fooResults>
+      </fooResults:1>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:1>
+    <Generator::current>
+    </Generator::current:1>
 1
-    <fooResults>
-    </fooResults:2>
+    <Generator::current>
+    </Generator::current:1>
+    <Generator::next>
+      <fooResults>
+      </fooResults:2>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:2>
+    <Generator::current>
+    </Generator::current:2>
 2
-    <fooResults>
-    </fooResults:3>
+    <Generator::current>
+    </Generator::current:2>
+    <Generator::next>
+      <fooResults>
+      </fooResults:3>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:3>
+    <Generator::current>
+    </Generator::current:3>
 3
-    <fooResults>
-    </fooResults:4>
+    <Generator::current>
+    </Generator::current:3>
+    <Generator::next>
+      <fooResults>
+      </fooResults:4>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:4>
+    <Generator::current>
+    </Generator::current:4>
 4
-    <fooResults>
-    </fooResults:5>
+    <Generator::current>
+    </Generator::current:4>
+    <Generator::next>
+      <fooResults>
+      </fooResults:5>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:5>
+    <Generator::current>
+    </Generator::current:5>
 5
-    <fooResults>
-    </fooResults:NULL>
+    <Generator::current>
+    </Generator::current:5>
+    <!-- init Generator::send() -->
+    <Generator::send>
+      <fooResults>
+      </fooResults:NULL>
+    </Generator::send:NULL>
+    <Generator::next>
+    </Generator::next:NULL>
+    <Generator::current>
+    </Generator::current:NULL>
   </doSomething:'Done'>
 Done
-</file '%s%eobserver_generator_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_generator_05.phpt b/ext/zend_test/tests/observer_generator_05.phpt
index d106be2ba6a..dc750bf3ca5 100644
--- a/ext/zend_test/tests/observer_generator_05.phpt
+++ b/ext/zend_test/tests/observer_generator_05.phpt
@@ -26,8 +26,8 @@ function doSomething() {
 echo doSomething() . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_generator_%d.php' -->
-<file '%s%eobserver_generator_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init doSomething() -->
   <doSomething>
     <!-- init fooResults() -->
@@ -38,12 +38,27 @@ echo doSomething() . PHP_EOL;
     </fooResults:1>
 1
     <fooResults>
+      <!-- init Exception::__construct() -->
+      <Exception::__construct>
+      </Exception::__construct:NULL>
       <!-- Exception: RuntimeException -->
     </fooResults:NULL>
     <!-- Exception: RuntimeException -->
   </doSomething:NULL>
   <!-- Exception: RuntimeException -->
-</file '%s%eobserver_generator_%d.php'>
+</file '%s'>
+<!-- init Exception::__toString() -->
+<Exception::__toString>
+  <!-- init Exception::getTraceAsString() -->
+  <Exception::getTraceAsString>
+  </Exception::getTraceAsString:'#0 %s(%d): fooResults()
+#1 %s(%d): doSomething()
+#2 {main}'>
+</Exception::__toString:'RuntimeException: Oops! in %s%eobserver_generator_%d.php:%d
+Stack trace:
+#0 %s%eobserver_generator_%d.php(%d): fooResults()
+#1 %s%eobserver_generator_%d.php(%d): doSomething()
+#2 {main}'>
 
 Fatal error: Uncaught RuntimeException: Oops! in %s%eobserver_generator_%d.php:%d
 Stack trace:
diff --git a/ext/zend_test/tests/observer_opline_01.phpt b/ext/zend_test/tests/observer_opline_01.phpt
index 35727349bb4..795597a124a 100644
--- a/ext/zend_test/tests/observer_opline_01.phpt
+++ b/ext/zend_test/tests/observer_opline_01.phpt
@@ -20,9 +20,9 @@ echo array_sum([1,2,3]) . PHP_EOL;
 foo();
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_opline_%d.php' -->
+<!-- init '%s' -->
 <!-- opcode: 'ZEND_INIT_FCALL' -->
-<file '%s%eobserver_opline_%d.php'>
+<file '%s'>
   <!-- opcode: 'ZEND_INIT_FCALL' -->
   <!-- init foo() -->
   <!-- opcode: 'ZEND_ECHO' -->
@@ -31,9 +31,9 @@ foo();
 Foo
     <!-- opcode: 'ZEND_RETURN' -->
   </foo>
-  <!-- init '%s%eobserver.inc' -->
+  <!-- init '%s' -->
   <!-- opcode: 'ZEND_INIT_FCALL' -->
-  <file '%s%eobserver.inc'>
+  <file '%s'>
     <!-- opcode: 'ZEND_INIT_FCALL' -->
     <!-- init foo_observer_test() -->
     <!-- opcode: 'ZEND_ECHO' -->
@@ -43,7 +43,13 @@ foo_observer_test
       <!-- opcode: 'ZEND_RETURN' -->
     </foo_observer_test>
     <!-- opcode: 'ZEND_RETURN' -->
-  </file '%s%eobserver.inc'>
+  </file '%s'>
+  <!-- init array_sum() -->
+  <!-- opcode: 'ZEND_RETURN' -->
+  <array_sum>
+    <!-- opcode: 'ZEND_RETURN' -->
+    <!-- opcode: 'ZEND_RETURN' -->
+  </array_sum>
 6
   <foo>
     <!-- opcode: 'ZEND_ECHO' -->
@@ -51,4 +57,4 @@ Foo
     <!-- opcode: 'ZEND_RETURN' -->
   </foo>
   <!-- opcode: 'ZEND_RETURN' -->
-</file '%s%eobserver_opline_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_retval_02.phpt b/ext/zend_test/tests/observer_retval_02.phpt
index 73992aa5831..4f037782e4e 100644
--- a/ext/zend_test/tests/observer_retval_02.phpt
+++ b/ext/zend_test/tests/observer_retval_02.phpt
@@ -21,12 +21,20 @@ $gen->current();
 echo 'Done' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_retval_%d.php' -->
-<file '%s%eobserver_retval_%d.php'>
-  <!-- init foo() -->
-  <foo>
-  </foo:'I should be observable'>
-  <foo>
-  </foo:'Me too!'>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init Generator::current() -->
+  <Generator::current>
+    <!-- init foo() -->
+    <foo>
+    </foo:'I should be observable'>
+  </Generator::current:'I should be observable'>
+  <!-- init Generator::next() -->
+  <Generator::next>
+    <foo>
+    </foo:'Me too!'>
+  </Generator::next:NULL>
+  <Generator::current>
+  </Generator::current:'Me too!'>
 Done
-</file '%s%eobserver_retval_%d.php'>
+</file '%s'>
diff --git a/ext/zend_test/tests/observer_shutdown_01.phpt b/ext/zend_test/tests/observer_shutdown_01.phpt
index 837d0f7f2b7..b0ee1bd1a03 100644
--- a/ext/zend_test/tests/observer_shutdown_01.phpt
+++ b/ext/zend_test/tests/observer_shutdown_01.phpt
@@ -24,13 +24,16 @@ function foo() {
 echo 'Done: ' . bar(40) . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_shutdown_%d.php' -->
-<file '%s%eobserver_shutdown_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init register_shutdown_function() -->
+  <register_shutdown_function>
+  </register_shutdown_function:NULL>
   <!-- init bar() -->
   <bar>
   </bar:40>
 Done: 40
-</file '%s%eobserver_shutdown_%d.php'>
+</file '%s'>
 <!-- init {closure}() -->
 <{closure}>
   <!-- init foo() -->
diff --git a/ext/zend_test/tests/observer_types_01.phpt b/ext/zend_test/tests/observer_types_01.phpt
index 7176ab32b49..de03b355ab1 100644
--- a/ext/zend_test/tests/observer_types_01.phpt
+++ b/ext/zend_test/tests/observer_types_01.phpt
@@ -12,14 +12,24 @@ function foo(array $a) { return 1; }
 foo(42);
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_types_%d.php' -->
-<file '%s%eobserver_types_%d.php'>
+<!-- init '%s' -->
+<file '%s'>
   <!-- init foo() -->
   <foo>
     <!-- Exception: TypeError -->
   </foo:NULL>
   <!-- Exception: TypeError -->
-</file '%s%eobserver_types_%d.php'>
+</file '%s'>
+<!-- init Error::__toString() -->
+<Error::__toString>
+  <!-- init Error::getTraceAsString() -->
+  <Error::getTraceAsString>
+  </Error::getTraceAsString:'#0 %s(%d): foo(42)
+#1 {main}'>
+</Error::__toString:'TypeError: foo(): Argument #1 ($a) must be of type array, int given, called in %s:%d
+Stack trace:
+#0 %s%eobserver_types_%d.php(%d): foo(42)
+#1 {main}'>
 
 Fatal error: Uncaught TypeError: foo(): Argument #1 ($a) must be of type array, int given, called in %s:%d
 Stack trace:
diff --git a/ext/zend_test/tests/observer_zend_call_function_01.phpt b/ext/zend_test/tests/observer_zend_call_function_01.phpt
index e148c9b20bd..aed1541f918 100644
--- a/ext/zend_test/tests/observer_zend_call_function_01.phpt
+++ b/ext/zend_test/tests/observer_zend_call_function_01.phpt
@@ -18,19 +18,25 @@ var_dump(array_reduce($a, 'sum'));
 echo 'Done' . PHP_EOL;
 ?>
 --EXPECTF--
-<!-- init '%s%eobserver_zend_call_function_%d.php' -->
-<file '%s%eobserver_zend_call_function_%d.php'>
-  <!-- init sum() -->
-  <sum>
-  </sum>
-  <sum>
-  </sum>
-  <sum>
-  </sum>
-  <sum>
-  </sum>
-  <sum>
-  </sum>
+<!-- init '%s' -->
+<file '%s'>
+  <!-- init array_reduce() -->
+  <array_reduce>
+    <!-- init sum() -->
+    <sum>
+    </sum>
+    <sum>
+    </sum>
+    <sum>
+    </sum>
+    <sum>
+    </sum>
+    <sum>
+    </sum>
+  </array_reduce>
+  <!-- init var_dump() -->
+  <var_dump>
 int(15)
+  </var_dump>
 Done
-</file '%s%eobserver_zend_call_function_%d.php'>
+</file '%s'>