Add zend_observer API

Closes GH-5857.

Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
Co-authored-by: Sammy Powers <sammyk@datadoghq.com>

32 files changed, 4604 insertions, 1385 deletions

diff --git a/Zend/zend.c b/Zend/zend.c
index 2e2ff03213..88530faa06 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -33,6 +33,7 @@
 #include "zend_smart_string.h"
 #include "zend_cpuinfo.h"
 #include "zend_attributes.h"
+#include "zend_observer.h"
 
 static size_t global_map_ptr_last = 0;
 
@@ -1205,6 +1206,7 @@ ZEND_API void zend_activate(void) /* {{{ */
 	if (CG(map_ptr_last)) {
 		memset(ZEND_MAP_PTR_REAL_BASE(CG(map_ptr_base)), 0, CG(map_ptr_last) * sizeof(void*));
 	}
+	zend_observer_activate();
 }
 /* }}} */
 
@@ -1221,6 +1223,8 @@ ZEND_API void zend_deactivate(void) /* {{{ */
 	/* we're no longer executing anything */
 	EG(current_execute_data) = NULL;
 
+	zend_observer_deactivate();
+
 	zend_try {
 		shutdown_scanner();
 	} zend_end_try();
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index bf93e89d60..4f2fbb7425 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -40,6 +40,7 @@
 #include "zend_inheritance.h"
 #include "zend_type_info.h"
 #include "zend_smart_str.h"
+#include "zend_observer.h"
 
 /* Virtual current working directory support */
 #include "zend_virtual_cwd.h"
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 6286b77f18..b8c3f11974 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -35,6 +35,7 @@
 #include "zend_float.h"
 #include "zend_weakrefs.h"
 #include "zend_inheritance.h"
+#include "zend_observer.h"
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
@@ -869,6 +870,9 @@ cleanup_args:
 		uint32_t orig_jit_trace_num = EG(jit_trace_num);
 
 		zend_init_func_execute_data(call, &func->op_array, fci->retval);
+		if (ZEND_OBSERVER_ENABLED) {
+			zend_observer_maybe_fcall_call_begin(call);
+		}
 		zend_execute_ex(call);
 		EG(jit_trace_num) = orig_jit_trace_num;
 		EG(opline_before_exception) = current_opline_before_exception;
diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 3fbac811ac..c890669a70 100644
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -24,6 +24,7 @@
 #include "zend_generators.h"
 #include "zend_closures.h"
 #include "zend_generators_arginfo.h"
+#include "zend_observer.h"
 
 ZEND_API zend_class_entry *zend_ce_generator;
 ZEND_API zend_class_entry *zend_ce_ClosedGeneratorException;
@@ -774,7 +775,25 @@ try_again:
 
 		/* Resume execution */
 		generator->flags |= ZEND_GENERATOR_CURRENTLY_RUNNING;
-		zend_execute_ex(generator->execute_data);
+		if (!ZEND_OBSERVER_ENABLED) {
+			zend_execute_ex(generator->execute_data);
+		} else {
+			zend_op_array *op_array = &generator->execute_data->func->op_array;
+			void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array);
+			if (!observer_handlers) {
+				zend_observer_fcall_install((zend_function *)op_array);
+				observer_handlers = ZEND_OBSERVER_HANDLERS(op_array);
+			}
+			ZEND_ASSERT(observer_handlers);
+			if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) {
+				zend_observe_fcall_begin(observer_handlers, generator->execute_data);
+			}
+			zend_execute_ex(generator->execute_data);
+			if (generator->execute_data) {
+				/* On the final return, this will be called from ZEND_GENERATOR_RETURN */
+				zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->value);
+			}
+		}
 		generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING;
 
 		generator->frozen_call_stack = NULL;
diff --git a/Zend/zend_observer.c b/Zend/zend_observer.c
new file mode 100644
index 0000000000..033551c6e9
--- /dev/null
+++ b/Zend/zend_observer.c
@@ -0,0 +1,160 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Levi Morrison <levim@php.net>                               |
+   |          Sammy Kaye Powers <sammyk@php.net>                          |
+   +----------------------------------------------------------------------+
+*/
+
+#include "zend_observer.h"
+
+#include "zend_extensions.h"
+#include "zend_llist.h"
+#include "zend_vm.h"
+
+zend_llist zend_observers_fcall_list;
+int zend_observer_fcall_op_array_extension = -1;
+
+ZEND_TLS zend_arena *fcall_handlers_arena = NULL;
+
+ZEND_API extern inline void zend_observer_maybe_fcall_call_begin(
+	zend_execute_data *execute_data);
+ZEND_API extern inline void zend_observer_maybe_fcall_call_end(
+	zend_execute_data *execute_data,
+	zval *return_value);
+
+// Call during minit/startup ONLY
+ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init) {
+	/* We don't want to get an extension handle unless an ext installs an observer */
+	if (!ZEND_OBSERVER_ENABLED) {
+		zend_observer_fcall_op_array_extension =
+			zend_get_op_array_extension_handle();
+
+		/* ZEND_CALL_TRAMPOLINE has SPEC(OBSERVER) but zend_init_call_trampoline_op()
+		 * is called before any extensions have registered as an observer. So we
+		 * adjust the offset to the observed handler when we know we need to observe. */
+		ZEND_VM_SET_OPCODE_HANDLER(&EG(call_trampoline_op));
+
+		/* ZEND_HANDLE_EXCEPTION also has SPEC(OBSERVER) and no observer extensions
+		 * exist when zend_init_exception_op() is called. */
+		ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op));
+		ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+1);
+		ZEND_VM_SET_OPCODE_HANDLER(EG(exception_op)+2);
+	}
+	zend_llist_add_element(&zend_observers_fcall_list, &init);
+}
+
+// Called by engine before MINITs
+ZEND_API void zend_observer_startup(void) {
+	zend_llist_init(&zend_observers_fcall_list, sizeof(zend_observer_fcall_init), NULL, 1);
+}
+
+ZEND_API void zend_observer_activate(void) {
+	if (ZEND_OBSERVER_ENABLED) {
+		fcall_handlers_arena = zend_arena_create(4096);
+	}
+}
+
+ZEND_API void zend_observer_deactivate(void) {
+	if (fcall_handlers_arena) {
+		zend_arena_destroy(fcall_handlers_arena);
+	}
+}
+
+ZEND_API void zend_observer_shutdown(void) {
+	zend_llist_destroy(&zend_observers_fcall_list);
+}
+
+ZEND_API void zend_observer_fcall_install(zend_function *function) {
+	zend_llist_element *element;
+	zend_llist *list = &zend_observers_fcall_list;
+	zend_op_array *op_array = &function->op_array;
+
+	if (fcall_handlers_arena == NULL) {
+		return;
+	}
+
+	ZEND_ASSERT(function->type != ZEND_INTERNAL_FUNCTION);
+
+	zend_llist handlers_list;
+	zend_llist_init(&handlers_list, sizeof(zend_observer_fcall), NULL, 0);
+	for (element = list->head; element; element = element->next) {
+		zend_observer_fcall_init init;
+		memcpy(&init, element->data, sizeof init);
+		zend_observer_fcall handlers = init(function);
+		if (handlers.begin || handlers.end) {
+			zend_llist_add_element(&handlers_list, &handlers);
+		}
+	}
+
+	ZEND_ASSERT(RUN_TIME_CACHE(op_array));
+	void *ext;
+	if (handlers_list.count) {
+		size_t size = sizeof(zend_observer_fcall_cache) + (handlers_list.count - 1) * sizeof(zend_observer_fcall);
+		zend_observer_fcall_cache *cache = zend_arena_alloc(&fcall_handlers_arena, size);
+		zend_observer_fcall *handler = cache->handlers;
+		for (element = handlers_list.head; element; element = element->next) {
+			memcpy(handler++, element->data, sizeof *handler);
+		}
+		cache->end = handler;
+		ext = cache;
+	} else {
+		ext = ZEND_OBSERVER_NOT_OBSERVED;
+	}
+
+	ZEND_OBSERVER_HANDLERS(op_array) = ext;
+	zend_llist_destroy(&handlers_list);
+}
+
+ZEND_API void zend_observe_fcall_begin(
+	zend_observer_fcall_cache *cache,
+	zend_execute_data *execute_data)
+{
+	zend_observer_fcall *handler, *end = cache->end;
+	for (handler = cache->handlers; handler != end; ++handler) {
+		if (handler->begin) {
+			handler->begin(execute_data);
+		}
+	}
+}
+
+ZEND_API void zend_observer_fcall_call_end_helper(
+	zend_execute_data *execute_data,
+	zval *return_value)
+{
+	zend_function *func = execute_data->func;
+	ZEND_ASSUME(ZEND_OBSERVABLE_FN(func->common.fn_flags));
+	void *observer_handlers = ZEND_OBSERVER_HANDLERS(&func->op_array);
+	// TODO: Fix exceptions from generators
+	// ZEND_ASSERT(observer_handlers);
+	if (observer_handlers && observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) {
+		zend_observer_fcall_cache *cache = observer_handlers;
+		zend_observe_fcall_end(cache, execute_data, return_value);
+	}
+}
+
+ZEND_API void zend_observe_fcall_end(
+	zend_observer_fcall_cache *cache,
+	zend_execute_data *execute_data,
+	zval *return_value)
+{
+	zend_observer_fcall *handler = cache->end, *end = cache->handlers;
+	while (handler-- != end) {
+		if (handler->end) {
+			handler->end(execute_data, return_value);
+		}
+	}
+}
+
+
diff --git a/Zend/zend_observer.h b/Zend/zend_observer.h
new file mode 100644
index 0000000000..9fb538ce3d
--- /dev/null
+++ b/Zend/zend_observer.h
@@ -0,0 +1,115 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Levi Morrison <levim@php.net>                               |
+   |          Sammy Kaye Powers <sammyk@php.net>                          |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_OBSERVER_H
+#define ZEND_OBSERVER_H
+
+#include "zend.h"
+#include "zend_compile.h"
+
+BEGIN_EXTERN_C()
+
+extern ZEND_API int zend_observer_fcall_op_array_extension;
+
+#define ZEND_OBSERVER_ENABLED (zend_observer_fcall_op_array_extension != -1)
+
+#define ZEND_OBSERVER_HANDLERS(op_array) \
+	ZEND_OP_ARRAY_EXTENSION(op_array, zend_observer_fcall_op_array_extension)
+
+#define ZEND_OBSERVER_NOT_OBSERVED ((void *) 2)
+
+#define ZEND_OBSERVABLE_FN(fn_flags) \
+	(ZEND_OBSERVER_ENABLED && \
+		!(fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_FAKE_CLOSURE)))
+
+struct zend_observer_fcall {
+	void (*begin)(zend_execute_data *execute_data);
+	void (*end)(zend_execute_data *execute_data, zval *retval);
+};
+typedef struct zend_observer_fcall zend_observer_fcall;
+
+struct zend_observer_fcall_cache {
+	// points after the last handler
+	zend_observer_fcall *end;
+	// a variadic array using "struct hack"
+	zend_observer_fcall handlers[1];
+};
+typedef struct zend_observer_fcall_cache zend_observer_fcall_cache;
+
+/* If the fn should not be observed then return {NULL, NULL} */
+typedef zend_observer_fcall(*zend_observer_fcall_init)(zend_function *func);
+
+// Call during minit/startup ONLY
+ZEND_API void zend_observer_fcall_register(zend_observer_fcall_init init);
+
+ZEND_API void zend_observer_startup(void); // Called by engine before MINITs
+ZEND_API void zend_observer_activate(void);
+ZEND_API void zend_observer_deactivate(void);
+ZEND_API void zend_observer_shutdown(void);
+
+ZEND_API void zend_observer_fcall_install(zend_function *function);
+
+ZEND_API void zend_observe_fcall_begin(
+	zend_observer_fcall_cache *cache,
+	zend_execute_data *execute_data);
+
+ZEND_API void zend_observe_fcall_end(
+	zend_observer_fcall_cache *cache,
+	zend_execute_data *execute_data,
+	zval *return_value);
+
+ZEND_API void zend_observer_fcall_call_end_helper(
+	zend_execute_data *execute_data,
+	zval *return_value);
+
+ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_begin(
+	zend_execute_data *execute_data)
+{
+	ZEND_ASSUME(execute_data->func);
+	zend_op_array *op_array = &execute_data->func->op_array;
+	uint32_t fn_flags = op_array->fn_flags;
+	if (ZEND_OBSERVABLE_FN(fn_flags) && !(fn_flags & ZEND_ACC_GENERATOR)) {
+		void *observer_handlers = ZEND_OBSERVER_HANDLERS(op_array);
+		if (!observer_handlers) {
+			zend_observer_fcall_install((zend_function *)op_array);
+			observer_handlers = ZEND_OBSERVER_HANDLERS(op_array);
+		}
+
+		ZEND_ASSERT(observer_handlers);
+		if (observer_handlers != ZEND_OBSERVER_NOT_OBSERVED) {
+			zend_observe_fcall_begin(
+				(zend_observer_fcall_cache *)observer_handlers,
+				execute_data);
+		}
+	}
+}
+
+ZEND_API zend_always_inline void zend_observer_maybe_fcall_call_end(
+	zend_execute_data *execute_data,
+	zval *return_value)
+{
+	zend_function *func = execute_data->func;
+	if (ZEND_OBSERVABLE_FN(func->common.fn_flags)) {
+		zend_observer_fcall_call_end_helper(execute_data, return_value);
+	}
+}
+
+END_EXTERN_C()
+
+#endif /* ZEND_OBSERVER_H */
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 246c5a990d..af6d41db86 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -3940,7 +3940,7 @@ ZEND_VM_HOT_HANDLER(129, ZEND_DO_ICALL, ANY, ANY, SPEC(RETVAL))
 	ZEND_VM_CONTINUE();
 }
 
-ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 {
 	USE_OPLINE
 	zend_execute_data *call = EX(call);
@@ -3958,12 +3958,13 @@ ZEND_VM_HOT_HANDLER(130, ZEND_DO_UCALL, ANY, ANY, SPEC(RETVAL))
 	call->prev_execute_data = execute_data;
 	execute_data = call;
 	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+	OBSERVER_FCALL_BEGIN_HANDLERS(execute_data);
 	LOAD_OPLINE_EX();
 
 	ZEND_VM_ENTER_EX();
 }
 
-ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL,OBSERVER))
 {
 	USE_OPLINE
 	zend_execute_data *call = EX(call);
@@ -3982,6 +3983,7 @@ ZEND_VM_HOT_HANDLER(131, ZEND_DO_FCALL_BY_NAME, ANY, ANY, SPEC(RETVAL))
 		call->prev_execute_data = execute_data;
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+		OBSERVER_FCALL_BEGIN_HANDLERS(execute_data);
 		LOAD_OPLINE_EX();
 
 		ZEND_VM_ENTER_EX();
@@ -4053,7 +4055,7 @@ ZEND_VM_C_LABEL(fcall_by_name_end):
 	ZEND_VM_CONTINUE();
 }
 
-ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL,OBSERVER))
 {
 	USE_OPLINE
 	zend_execute_data *call = EX(call);
@@ -4072,6 +4074,7 @@ ZEND_VM_HOT_HANDLER(60, ZEND_DO_FCALL, ANY, ANY, SPEC(RETVAL))
 		call->prev_execute_data = execute_data;
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
+		OBSERVER_FCALL_BEGIN_HANDLERS(execute_data);
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
 			LOAD_OPLINE_EX();
@@ -4220,7 +4223,7 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV
 	}
 }
 
-ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER))
 {
 	USE_OPLINE
 	zval *retval_ptr;
@@ -4289,10 +4292,11 @@ ZEND_VM_INLINE_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 			}
 		}
 	}
+	OBSERVER_FCALL_END_HANDLERS(execute_data, return_value);
 	ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
 }
 
-ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC)
+ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC, SPEC(OBSERVER))
 {
 	USE_OPLINE
 	zval *retval_ptr;
@@ -4349,6 +4353,7 @@ ZEND_VM_COLD_CONST_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY, SRC)
 		FREE_OP1_VAR_PTR();
 	} while (0);
 
+	OBSERVER_FCALL_END_HANDLERS(execute_data, EX(return_value));
 	ZEND_VM_DISPATCH_TO_HELPER(zend_leave_helper);
 }
 
@@ -4428,7 +4433,7 @@ ZEND_VM_HANDLER(139, ZEND_GENERATOR_CREATE, ANY, ANY)
 	}
 }
 
-ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY, SPEC(OBSERVER))
 {
 	USE_OPLINE
 	zval *retval;
@@ -4464,6 +4469,8 @@ ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, CONST|TMP|VAR|CV, ANY)
 		}
 	}
 
+	OBSERVER_FCALL_END_HANDLERS(generator->execute_data, &generator->retval);
+
 	/* Close the generator to free up resources */
 	zend_generator_close(generator, 1);
 
@@ -6134,7 +6141,7 @@ ZEND_VM_COLD_CONST_HANDLER(51, ZEND_CAST, CONST|TMP|VAR|CV, ANY, TYPE)
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
-ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
+ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL, SPEC(OBSERVER))
 {
 	USE_OPLINE
 	zend_op_array *new_op_array;
@@ -6143,8 +6150,8 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
 	SAVE_OPLINE();
 	inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
-	FREE_OP1();
 	if (UNEXPECTED(EG(exception) != NULL)) {
+		FREE_OP1();
 		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
 			destroy_op_array(new_op_array);
 			efree_size(new_op_array, sizeof(zend_op_array));
@@ -6178,7 +6185,9 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
 
 		call->prev_execute_data = execute_data;
 		i_init_code_execute_data(call, new_op_array, return_value);
+		OBSERVER_FCALL_BEGIN_HANDLERS(call);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			FREE_OP1();
 			ZEND_VM_ENTER();
 		} else {
 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
@@ -6190,12 +6199,14 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMPVAR|CV, ANY, EVAL)
 		efree_size(new_op_array, sizeof(zend_op_array));
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			zend_rethrow_exception(execute_data);
+			FREE_OP1();
 			UNDEF_RESULT();
 			HANDLE_EXCEPTION();
 		}
 	} else if (RETURN_VALUE_USED(opline)) {
 		ZVAL_FALSE(EX_VAR(opline->result.var));
 	}
+	FREE_OP1();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -7688,7 +7699,7 @@ ZEND_VM_HELPER(zend_dispatch_try_catch_finally_helper, ANY, ANY, uint32_t try_ca
 	}
 }
 
-ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
+ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY, SPEC(OBSERVER))
 {
 	const zend_op *throw_op = EG(opline_before_exception);
 	uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
@@ -7717,6 +7728,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 		}
 	}
 
+	OBSERVER_FCALL_END_HANDLERS(execute_data, EX(return_value));
 	cleanup_unfinished_calls(execute_data, throw_op_num);
 
 	if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
@@ -8420,7 +8432,7 @@ ZEND_VM_HANDLER(157, ZEND_FETCH_CLASS_NAME, CV|TMPVAR|UNUSED|CLASS_FETCH, ANY)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY)
+ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY, SPEC(OBSERVER))
 {
 	zend_array *args = NULL;
 	zend_function *fbc = EX(func);
@@ -8478,6 +8490,7 @@ ZEND_VM_HANDLER(158, ZEND_CALL_TRAMPOLINE, ANY, ANY)
 		}
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+		OBSERVER_FCALL_BEGIN_HANDLERS(execute_data);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
 			LOAD_OPLINE_EX();
 			ZEND_VM_ENTER_EX();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 4b3958a4e4..14d9670ee4 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -316,6 +316,7 @@ static zend_uchar zend_user_opcodes[256] = {0,
 #define SPEC_RULE_SMART_BRANCH 0x00200000
 #define SPEC_RULE_COMMUTATIVE  0x00800000
 #define SPEC_RULE_ISSET        0x01000000
+#define SPEC_RULE_OBSERVER     0x02000000
 
 static const uint32_t *zend_spec_handlers;
 static const void * const *zend_opcode_handlers;
@@ -1349,6 +1350,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV
 	call->prev_execute_data = execute_data;
 	execute_data = call;
 	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+
 	LOAD_OPLINE_EX();
 
 	ZEND_VM_ENTER_EX();
@@ -1372,6 +1374,55 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETV
 	call->prev_execute_data = execute_data;
 	execute_data = call;
 	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+
+	LOAD_OPLINE_EX();
+
+	ZEND_VM_ENTER_EX();
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	ret = NULL;
+	if (0) {
+		ret = EX_VAR(opline->result.var);
+	}
+
+	call->prev_execute_data = execute_data;
+	execute_data = call;
+	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+	zend_observer_maybe_fcall_call_begin(execute_data);
+	LOAD_OPLINE_EX();
+
+	ZEND_VM_ENTER_EX();
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	ret = NULL;
+	if (1) {
+		ret = EX_VAR(opline->result.var);
+	}
+
+	call->prev_execute_data = execute_data;
+	execute_data = call;
+	i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+	zend_observer_maybe_fcall_call_begin(execute_data);
 	LOAD_OPLINE_EX();
 
 	ZEND_VM_ENTER_EX();
@@ -1396,6 +1447,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S
 		call->prev_execute_data = execute_data;
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+
 		LOAD_OPLINE_EX();
 
 		ZEND_VM_ENTER_EX();
@@ -1486,6 +1538,189 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_S
 		call->prev_execute_data = execute_data;
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+
+		LOAD_OPLINE_EX();
+
+		ZEND_VM_ENTER_EX();
+	} else {
+		zval retval;
+		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
+
+		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
+			zend_deprecated_function(fbc);
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				UNDEF_RESULT();
+				if (!1) {
+					ret = &retval;
+					ZVAL_UNDEF(ret);
+				}
+				goto fcall_by_name_end;
+			}
+		}
+
+		call->prev_execute_data = execute_data;
+		EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+		ret = 1 ? EX_VAR(opline->result.var) : &retval;
+		ZVAL_NULL(ret);
+
+		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));
+		}
+#endif
+
+		EG(current_execute_data) = execute_data;
+
+fcall_by_name_end:
+		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 (!1) {
+			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_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
+		ret = NULL;
+		if (0) {
+			ret = EX_VAR(opline->result.var);
+		}
+
+		call->prev_execute_data = execute_data;
+		execute_data = call;
+		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+		zend_observer_maybe_fcall_call_begin(execute_data);
+		LOAD_OPLINE_EX();
+
+		ZEND_VM_ENTER_EX();
+	} else {
+		zval retval;
+		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
+
+		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
+			zend_deprecated_function(fbc);
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				UNDEF_RESULT();
+				if (!0) {
+					ret = &retval;
+					ZVAL_UNDEF(ret);
+				}
+				goto fcall_by_name_end;
+			}
+		}
+
+		call->prev_execute_data = execute_data;
+		EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+		ret = 0 ? EX_VAR(opline->result.var) : &retval;
+		ZVAL_NULL(ret);
+
+		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));
+		}
+#endif
+
+		EG(current_execute_data) = execute_data;
+
+fcall_by_name_end:
+		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 (!0) {
+			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_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
+		ret = NULL;
+		if (1) {
+			ret = EX_VAR(opline->result.var);
+		}
+
+		call->prev_execute_data = execute_data;
+		execute_data = call;
+		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+		zend_observer_maybe_fcall_call_begin(execute_data);
 		LOAD_OPLINE_EX();
 
 		ZEND_VM_ENTER_EX();
@@ -1761,6 +1996,212 @@ fcall_end:
 	ZEND_VM_CONTINUE();
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
+		ret = NULL;
+		if (0) {
+			ret = EX_VAR(opline->result.var);
+		}
+
+		call->prev_execute_data = execute_data;
+		execute_data = call;
+		i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
+		zend_observer_maybe_fcall_call_begin(execute_data);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			LOAD_OPLINE_EX();
+			ZEND_VM_ENTER_EX();
+		} else {
+			SAVE_OPLINE_EX();
+			execute_data = EX(prev_execute_data);
+			LOAD_OPLINE();
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+		}
+	} else {
+		zval retval;
+		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
+
+		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
+			zend_deprecated_function(fbc);
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				UNDEF_RESULT();
+				if (!0) {
+					ret = &retval;
+					ZVAL_UNDEF(ret);
+				}
+				goto fcall_end;
+			}
+		}
+
+		call->prev_execute_data = execute_data;
+		EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+		ret = 0 ? EX_VAR(opline->result.var) : &retval;
+		ZVAL_NULL(ret);
+
+		if (!zend_execute_internal) {
+			/* saves one function call if zend_execute_internal is not used */
+			fbc->internal_function.handler(call, ret);
+		} else {
+			zend_execute_internal(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));
+		}
+#endif
+
+		EG(current_execute_data) = execute_data;
+
+fcall_end:
+		zend_vm_stack_free_args(call);
+		if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
+			zend_free_extra_named_params(call->extra_named_params);
+		}
+
+		if (!0) {
+			i_zval_ptr_dtor(ret);
+		}
+	}
+
+	if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
+		OBJ_RELEASE(Z_OBJ(call->This));
+	}
+
+	zend_vm_stack_free_call_frame(call);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		zend_rethrow_exception(execute_data);
+		HANDLE_EXCEPTION();
+	}
+
+	ZEND_VM_SET_OPCODE(opline + 1);
+	ZEND_VM_CONTINUE();
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_execute_data *call = EX(call);
+	zend_function *fbc = call->func;
+	zval *ret;
+
+	SAVE_OPLINE();
+	EX(call) = call->prev_execute_data;
+
+	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
+		ret = NULL;
+		if (1) {
+			ret = EX_VAR(opline->result.var);
+		}
+
+		call->prev_execute_data = execute_data;
+		execute_data = call;
+		i_init_func_execute_data(&fbc->op_array, ret, 1 EXECUTE_DATA_CC);
+		zend_observer_maybe_fcall_call_begin(execute_data);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			LOAD_OPLINE_EX();
+			ZEND_VM_ENTER_EX();
+		} else {
+			SAVE_OPLINE_EX();
+			execute_data = EX(prev_execute_data);
+			LOAD_OPLINE();
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+		}
+	} else {
+		zval retval;
+		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
+
+		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
+			zend_deprecated_function(fbc);
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				UNDEF_RESULT();
+				if (!1) {
+					ret = &retval;
+					ZVAL_UNDEF(ret);
+				}
+				goto fcall_end;
+			}
+		}
+
+		call->prev_execute_data = execute_data;
+		EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+		ret = 1 ? EX_VAR(opline->result.var) : &retval;
+		ZVAL_NULL(ret);
+
+		if (!zend_execute_internal) {
+			/* saves one function call if zend_execute_internal is not used */
+			fbc->internal_function.handler(call, ret);
+		} else {
+			zend_execute_internal(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));
+		}
+#endif
+
+		EG(current_execute_data) = execute_data;
+
+fcall_end:
+		zend_vm_stack_free_args(call);
+		if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
+			zend_free_extra_named_params(call->extra_named_params);
+		}
+
+		if (!1) {
+			i_zval_ptr_dtor(ret);
+		}
+	}
+
+	if (UNEXPECTED(ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS)) {
+		OBJ_RELEASE(Z_OBJ(call->This));
+	}
+
+	zend_vm_stack_free_call_frame(call);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		zend_rethrow_exception(execute_data);
+		HANDLE_EXCEPTION();
+	}
+
+	ZEND_VM_SET_OPCODE(opline + 1);
+	ZEND_VM_CONTINUE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	zval *return_value = EX(return_value);
@@ -2720,6 +3161,61 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(
 	ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	const zend_op *throw_op = EG(opline_before_exception);
+	uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes;
+	int i, current_try_catch_offset = -1;
+
+	if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE)
+		&& throw_op->extended_value & ZEND_FREE_ON_RETURN) {
+		/* exceptions thrown because of loop var destruction on return/break/...
+		 * are logically thrown at the end of the foreach loop, so adjust the
+		 * throw_op_num.
+		 */
+		const zend_live_range *range = find_live_range(
+			&EX(func)->op_array, throw_op_num, throw_op->op1.var);
+		throw_op_num = range->end;
+	}
+
+	/* Find the innermost try/catch/finally the exception was thrown in */
+	for (i = 0; i < EX(func)->op_array.last_try_catch; i++) {
+		zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i];
+		if (try_catch->try_op > throw_op_num) {
+			/* further blocks will not be relevant... */
+			break;
+		}
+		if (throw_op_num < try_catch->catch_op || throw_op_num < try_catch->finally_end) {
+			current_try_catch_offset = i;
+		}
+	}
+
+	zend_observer_maybe_fcall_call_end(execute_data, EX(return_value));
+	cleanup_unfinished_calls(execute_data, throw_op_num);
+
+	if (throw_op->result_type & (IS_VAR | IS_TMP_VAR)) {
+		switch (throw_op->opcode) {
+			case ZEND_ADD_ARRAY_ELEMENT:
+			case ZEND_ADD_ARRAY_UNPACK:
+			case ZEND_ROPE_INIT:
+			case ZEND_ROPE_ADD:
+				break; /* exception while building structures, live range handling will free those */
+
+			case ZEND_FETCH_CLASS:
+			case ZEND_DECLARE_ANON_CLASS:
+				break; /* return value is zend_class_entry pointer */
+
+			default:
+				/* smart branch opcodes may not initialize result */
+				if (!zend_is_smart_branch(throw_op)) {
+					zval_ptr_dtor_nogc(EX_VAR(throw_op->result.var));
+				}
+		}
+	}
+
+	ZEND_VM_TAIL_CALL(zend_dispatch_try_catch_finally_helper_SPEC(current_try_catch_offset, throw_op_num ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_CC));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -2891,6 +3387,141 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(Z
 		}
 		execute_data = call;
 		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			LOAD_OPLINE_EX();
+			ZEND_VM_ENTER_EX();
+		} else {
+			SAVE_OPLINE_EX();
+			execute_data = EX(prev_execute_data);
+			LOAD_OPLINE();
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+		}
+	} else {
+		zval retval;
+
+		ZEND_ASSERT(fbc->type == ZEND_INTERNAL_FUNCTION);
+
+		EG(current_execute_data) = call;
+
+#if ZEND_DEBUG
+		zend_bool should_throw = zend_internal_call_should_throw(fbc, call);
+#endif
+
+		if (ret == NULL) {
+			ret = &retval;
+		}
+
+		ZVAL_NULL(ret);
+		if (!zend_execute_internal) {
+			/* saves one function call if zend_execute_internal is not used */
+			fbc->internal_function.handler(call, ret);
+		} else {
+			zend_execute_internal(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));
+		}
+#endif
+
+		EG(current_execute_data) = call->prev_execute_data;
+
+		zend_vm_stack_free_args(call);
+		if (ret == &retval) {
+			zval_ptr_dtor(ret);
+		}
+	}
+
+	execute_data = EG(current_execute_data);
+
+	if (!EX(func) || !ZEND_USER_CODE(EX(func)->type) || (call_info & ZEND_CALL_TOP)) {
+		ZEND_VM_RETURN();
+	}
+
+	if (UNEXPECTED(call_info & ZEND_CALL_RELEASE_THIS)) {
+		zend_object *object = Z_OBJ(call->This);
+		OBJ_RELEASE(object);
+	}
+	zend_vm_stack_free_call_frame(call);
+
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		zend_rethrow_exception(execute_data);
+		HANDLE_EXCEPTION_LEAVE();
+	}
+
+	LOAD_OPLINE();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_LEAVE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	zend_array *args = NULL;
+	zend_function *fbc = EX(func);
+	zval *ret = EX(return_value);
+	uint32_t call_info = EX_CALL_INFO() & (ZEND_CALL_NESTED | ZEND_CALL_TOP | ZEND_CALL_RELEASE_THIS | ZEND_CALL_HAS_EXTRA_NAMED_PARAMS);
+	uint32_t num_args = EX_NUM_ARGS();
+	zend_execute_data *call;
+
+	SAVE_OPLINE();
+
+	if (num_args) {
+		zval *p = ZEND_CALL_ARG(execute_data, 1);
+		zval *end = p + num_args;
+
+		args = zend_new_array(num_args);
+		zend_hash_real_init_packed(args);
+		ZEND_HASH_FILL_PACKED(args) {
+			do {
+				ZEND_HASH_FILL_ADD(p);
+				p++;
+			} while (p != end);
+		} ZEND_HASH_FILL_END();
+	}
+
+	call = execute_data;
+	execute_data = EG(current_execute_data) = EX(prev_execute_data);
+
+	call->func = (fbc->op_array.fn_flags & ZEND_ACC_STATIC) ? fbc->op_array.scope->__callstatic : fbc->op_array.scope->__call;
+	ZEND_ASSERT(zend_vm_calc_used_stack(2, call->func) <= (size_t)(((char*)EG(vm_stack_end)) - (char*)call));
+	ZEND_CALL_NUM_ARGS(call) = 2;
+
+	ZVAL_STR(ZEND_CALL_ARG(call, 1), fbc->common.function_name);
+
+	zval *call_args = ZEND_CALL_ARG(call, 2);
+	if (args) {
+		ZVAL_ARR(call_args, args);
+	} else {
+		ZVAL_EMPTY_ARRAY(call_args);
+	}
+	if (UNEXPECTED(call_info & ZEND_CALL_HAS_EXTRA_NAMED_PARAMS)) {
+		if (zend_hash_num_elements(Z_ARRVAL_P(call_args)) == 0) {
+			GC_ADDREF(call->extra_named_params);
+			ZVAL_ARR(call_args, call->extra_named_params);
+		} else {
+			SEPARATE_ARRAY(call_args);
+			zend_hash_copy(Z_ARRVAL_P(call_args), call->extra_named_params, zval_add_ref);
+		}
+	}
+	zend_free_trampoline(fbc);
+	fbc = call->func;
+
+	if (EXPECTED(fbc->type == ZEND_USER_FUNCTION)) {
+		if (UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) {
+			init_func_run_time_cache(&fbc->op_array);
+		}
+		execute_data = call;
+		i_init_func_execute_data(&fbc->op_array, ret, 0 EXECUTE_DATA_CC);
+		zend_observer_maybe_fcall_call_begin(execute_data);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
 			LOAD_OPLINE_EX();
 			ZEND_VM_ENTER_EX();
@@ -3691,6 +4322,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_
 			}
 		}
 	}
+
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = RT_CONSTANT(opline, opline->op1);
+	return_value = EX(return_value);
+	if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_CONST == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_CONST == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_CONST == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
@@ -3753,6 +4458,66 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPE
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+
+	SAVE_OPLINE();
+
+	do {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR)) ||
+		    (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
+			/* Not supposed to happen, but we'll allow it */
+			zend_error(E_NOTICE, "Only variable references should be returned by reference");
+
+			retval_ptr = RT_CONSTANT(opline, opline->op1);
+			if (!EX(return_value)) {
+
+			} else {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+					ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
+					break;
+				}
+
+				ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				if (IS_CONST == IS_CONST) {
+					Z_TRY_ADDREF_P(retval_ptr);
+				}
+			}
+			break;
+		}
+
+		retval_ptr = NULL;
+
+		if (IS_CONST == IS_VAR) {
+			ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+			if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
+				zend_error(E_NOTICE, "Only variable references should be returned by reference");
+				if (EX(return_value)) {
+					ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				} else {
+
+				}
+				break;
+			}
+		}
+
+		if (EX(return_value)) {
+			if (Z_ISREF_P(retval_ptr)) {
+				Z_ADDREF_P(retval_ptr);
+			} else {
+				ZVAL_MAKE_REF_EX(retval_ptr, 2);
+			}
+			ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
+		}
+
+	} while (0);
+
+	zend_observer_maybe_fcall_call_end(execute_data, EX(return_value));
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -3796,6 +4561,51 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_HA
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval;
+
+	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
+
+	SAVE_OPLINE();
+	retval = RT_CONSTANT(opline, opline->op1);
+
+	/* Copy return value into generator->retval */
+	if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+		ZVAL_COPY_VALUE(&generator->retval, retval);
+		if (IS_CONST == IS_CONST) {
+			if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
+				Z_ADDREF(generator->retval);
+			}
+		}
+	} else if (IS_CONST == IS_CV) {
+		ZVAL_COPY_DEREF(&generator->retval, retval);
+	} else /* if (IS_CONST == IS_VAR) */ {
+		if (UNEXPECTED(Z_ISREF_P(retval))) {
+			zend_refcounted *ref = Z_COUNTED_P(retval);
+
+			retval = Z_REFVAL_P(retval);
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+				efree_size(ref, sizeof(zend_reference));
+			} else if (Z_OPT_REFCOUNTED_P(retval)) {
+				Z_ADDREF_P(retval);
+			}
+		} else {
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+		}
+	}
+
+	zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval);
+
+	/* Close the generator to free up resources */
+	zend_generator_close(generator, 1);
+
+	/* Pass execution back to handling code */
+	ZEND_VM_RETURN();
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -4087,8 +4897,77 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN
 	SAVE_OPLINE();
 	inc_filename = RT_CONSTANT(opline, opline->op1);
 	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+
+		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
+			destroy_op_array(new_op_array);
+			efree_size(new_op_array, sizeof(zend_op_array));
+		}
+		UNDEF_RESULT();
+		HANDLE_EXCEPTION();
+	} else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_TRUE(EX_VAR(opline->result.var));
+		}
+	} else if (EXPECTED(new_op_array != NULL)) {
+		zval *return_value = NULL;
+		zend_execute_data *call;
+
+		if (RETURN_VALUE_USED(opline)) {
+			return_value = EX_VAR(opline->result.var);
+		}
+
+		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,
+			(zend_function*)new_op_array, 0,
+			Z_PTR(EX(This)));
+
+		if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
+			call->symbol_table = EX(symbol_table);
+		} else {
+			call->symbol_table = zend_rebuild_symbol_table();
+		}
+
+		call->prev_execute_data = execute_data;
+		i_init_code_execute_data(call, new_op_array, return_value);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+
+			ZEND_VM_ENTER();
+		} else {
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+			zend_vm_stack_free_call_frame(call);
+		}
+
+		destroy_op_array(new_op_array);
+		efree_size(new_op_array, sizeof(zend_op_array));
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_rethrow_exception(execute_data);
 
+			UNDEF_RESULT();
+			HANDLE_EXCEPTION();
+		}
+	} else if (RETURN_VALUE_USED(opline)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_op_array *new_op_array;
+	zval *inc_filename;
+
+	SAVE_OPLINE();
+	inc_filename = RT_CONSTANT(opline, opline->op1);
+	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
 	if (UNEXPECTED(EG(exception) != NULL)) {
+
 		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
 			destroy_op_array(new_op_array);
 			efree_size(new_op_array, sizeof(zend_op_array));
@@ -4122,7 +5001,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN
 
 		call->prev_execute_data = execute_data;
 		i_init_code_execute_data(call, new_op_array, return_value);
+		zend_observer_maybe_fcall_call_begin(call);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+
 			ZEND_VM_ENTER();
 		} else {
 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
@@ -4134,12 +5015,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HAN
 		efree_size(new_op_array, sizeof(zend_op_array));
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			zend_rethrow_exception(execute_data);
+
 			UNDEF_RESULT();
 			HANDLE_EXCEPTION();
 		}
 	} else if (RETURN_VALUE_USED(opline)) {
 		ZVAL_FALSE(EX_VAR(opline->result.var));
 	}
+
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -13575,8 +14458,77 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
 	SAVE_OPLINE();
 	inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
 	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+		zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
+			destroy_op_array(new_op_array);
+			efree_size(new_op_array, sizeof(zend_op_array));
+		}
+		UNDEF_RESULT();
+		HANDLE_EXCEPTION();
+	} else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_TRUE(EX_VAR(opline->result.var));
+		}
+	} else if (EXPECTED(new_op_array != NULL)) {
+		zval *return_value = NULL;
+		zend_execute_data *call;
+
+		if (RETURN_VALUE_USED(opline)) {
+			return_value = EX_VAR(opline->result.var);
+		}
+
+		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,
+			(zend_function*)new_op_array, 0,
+			Z_PTR(EX(This)));
+
+		if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
+			call->symbol_table = EX(symbol_table);
+		} else {
+			call->symbol_table = zend_rebuild_symbol_table();
+		}
+
+		call->prev_execute_data = execute_data;
+		i_init_code_execute_data(call, new_op_array, return_value);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+			ZEND_VM_ENTER();
+		} else {
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+			zend_vm_stack_free_call_frame(call);
+		}
+
+		destroy_op_array(new_op_array);
+		efree_size(new_op_array, sizeof(zend_op_array));
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_rethrow_exception(execute_data);
+			zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+			UNDEF_RESULT();
+			HANDLE_EXCEPTION();
+		}
+	} else if (RETURN_VALUE_USED(opline)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	}
 	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_op_array *new_op_array;
+	zval *inc_filename;
+
+	SAVE_OPLINE();
+	inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
 	if (UNEXPECTED(EG(exception) != NULL)) {
+		zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
 			destroy_op_array(new_op_array);
 			efree_size(new_op_array, sizeof(zend_op_array));
@@ -13610,7 +14562,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
 
 		call->prev_execute_data = execute_data;
 		i_init_code_execute_data(call, new_op_array, return_value);
+		zend_observer_maybe_fcall_call_begin(call);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+			zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			ZEND_VM_ENTER();
 		} else {
 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
@@ -13622,12 +14576,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HA
 		efree_size(new_op_array, sizeof(zend_op_array));
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			zend_rethrow_exception(execute_data);
+			zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 			UNDEF_RESULT();
 			HANDLE_EXCEPTION();
 		}
 	} else if (RETURN_VALUE_USED(opline)) {
 		ZVAL_FALSE(EX_VAR(opline->result.var));
 	}
+	zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -17931,6 +18887,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HA
 			}
 		}
 	}
+
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+	return_value = EX(return_value);
+	if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_TMP_VAR == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_TMP_VAR == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_TMP_VAR == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
@@ -17993,6 +19023,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+
+	SAVE_OPLINE();
+
+	do {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) ||
+		    (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
+			/* Not supposed to happen, but we'll allow it */
+			zend_error(E_NOTICE, "Only variable references should be returned by reference");
+
+			retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+			if (!EX(return_value)) {
+				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+			} else {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+					ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
+					break;
+				}
+
+				ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				if (IS_TMP_VAR == IS_CONST) {
+					Z_TRY_ADDREF_P(retval_ptr);
+				}
+			}
+			break;
+		}
+
+		retval_ptr = NULL;
+
+		if (IS_TMP_VAR == IS_VAR) {
+			ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+			if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
+				zend_error(E_NOTICE, "Only variable references should be returned by reference");
+				if (EX(return_value)) {
+					ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				} else {
+
+				}
+				break;
+			}
+		}
+
+		if (EX(return_value)) {
+			if (Z_ISREF_P(retval_ptr)) {
+				Z_ADDREF_P(retval_ptr);
+			} else {
+				ZVAL_MAKE_REF_EX(retval_ptr, 2);
+			}
+			ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
+		}
+
+	} while (0);
+
+	zend_observer_maybe_fcall_call_end(execute_data, EX(return_value));
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -18036,6 +19126,51 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_HAND
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval;
+
+	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
+
+	SAVE_OPLINE();
+	retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+
+	/* Copy return value into generator->retval */
+	if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+		ZVAL_COPY_VALUE(&generator->retval, retval);
+		if (IS_TMP_VAR == IS_CONST) {
+			if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
+				Z_ADDREF(generator->retval);
+			}
+		}
+	} else if (IS_TMP_VAR == IS_CV) {
+		ZVAL_COPY_DEREF(&generator->retval, retval);
+	} else /* if (IS_TMP_VAR == IS_VAR) */ {
+		if (UNEXPECTED(Z_ISREF_P(retval))) {
+			zend_refcounted *ref = Z_COUNTED_P(retval);
+
+			retval = Z_REFVAL_P(retval);
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+				efree_size(ref, sizeof(zend_reference));
+			} else if (Z_OPT_REFCOUNTED_P(retval)) {
+				Z_ADDREF_P(retval);
+			}
+		} else {
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+		}
+	}
+
+	zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval);
+
+	/* Close the generator to free up resources */
+	zend_generator_close(generator, 1);
+
+	/* Pass execution back to handling code */
+	ZEND_VM_RETURN();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -20477,6 +21612,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_HA
 			}
 		}
 	}
+
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+	return_value = EX(return_value);
+	if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_VAR == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_VAR == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_VAR == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
@@ -20540,6 +21749,67 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+
+	SAVE_OPLINE();
+
+	do {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR)) ||
+		    (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
+			/* Not supposed to happen, but we'll allow it */
+			zend_error(E_NOTICE, "Only variable references should be returned by reference");
+
+			retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+			if (!EX(return_value)) {
+				zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+			} else {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+					ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
+					break;
+				}
+
+				ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				if (IS_VAR == IS_CONST) {
+					Z_TRY_ADDREF_P(retval_ptr);
+				}
+			}
+			break;
+		}
+
+		retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+
+		if (IS_VAR == IS_VAR) {
+			ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+			if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
+				zend_error(E_NOTICE, "Only variable references should be returned by reference");
+				if (EX(return_value)) {
+					ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				} else {
+					zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+				}
+				break;
+			}
+		}
+
+		if (EX(return_value)) {
+			if (Z_ISREF_P(retval_ptr)) {
+				Z_ADDREF_P(retval_ptr);
+			} else {
+				ZVAL_MAKE_REF_EX(retval_ptr, 2);
+			}
+			ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
+		}
+
+		zval_ptr_dtor_nogc(EX_VAR(opline->op1.var));
+	} while (0);
+
+	zend_observer_maybe_fcall_call_end(execute_data, EX(return_value));
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -20583,6 +21853,51 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_HAND
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval;
+
+	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
+
+	SAVE_OPLINE();
+	retval = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+
+	/* Copy return value into generator->retval */
+	if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+		ZVAL_COPY_VALUE(&generator->retval, retval);
+		if (IS_VAR == IS_CONST) {
+			if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
+				Z_ADDREF(generator->retval);
+			}
+		}
+	} else if (IS_VAR == IS_CV) {
+		ZVAL_COPY_DEREF(&generator->retval, retval);
+	} else /* if (IS_VAR == IS_VAR) */ {
+		if (UNEXPECTED(Z_ISREF_P(retval))) {
+			zend_refcounted *ref = Z_COUNTED_P(retval);
+
+			retval = Z_REFVAL_P(retval);
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+				efree_size(ref, sizeof(zend_reference));
+			} else if (Z_OPT_REFCOUNTED_P(retval)) {
+				Z_ADDREF_P(retval);
+			}
+		} else {
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+		}
+	}
+
+	zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval);
+
+	/* Close the generator to free up resources */
+	zend_generator_close(generator, 1);
+
+	/* Pass execution back to handling code */
+	ZEND_VM_RETURN();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -36991,6 +38306,80 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_HAN
 			}
 		}
 	}
+
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = EX_VAR(opline->op1.var);
+	return_value = EX(return_value);
+	if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_CV == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_CV == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_CV == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
@@ -37053,6 +38442,66 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(
 	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
 }
 
+static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+
+	SAVE_OPLINE();
+
+	do {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR)) ||
+		    (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
+			/* Not supposed to happen, but we'll allow it */
+			zend_error(E_NOTICE, "Only variable references should be returned by reference");
+
+			retval_ptr = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+			if (!EX(return_value)) {
+
+			} else {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+					ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
+					break;
+				}
+
+				ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				if (IS_CV == IS_CONST) {
+					Z_TRY_ADDREF_P(retval_ptr);
+				}
+			}
+			break;
+		}
+
+		retval_ptr = _get_zval_ptr_cv_BP_VAR_W(opline->op1.var EXECUTE_DATA_CC);
+
+		if (IS_CV == IS_VAR) {
+			ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval));
+			if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) {
+				zend_error(E_NOTICE, "Only variable references should be returned by reference");
+				if (EX(return_value)) {
+					ZVAL_NEW_REF(EX(return_value), retval_ptr);
+				} else {
+
+				}
+				break;
+			}
+		}
+
+		if (EX(return_value)) {
+			if (Z_ISREF_P(retval_ptr)) {
+				Z_ADDREF_P(retval_ptr);
+			} else {
+				ZVAL_MAKE_REF_EX(retval_ptr, 2);
+			}
+			ZVAL_REF(EX(return_value), Z_REF_P(retval_ptr));
+		}
+
+	} while (0);
+
+	zend_observer_maybe_fcall_call_end(execute_data, EX(return_value));
+	ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU));
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -37096,6 +38545,51 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_HANDL
 	ZEND_VM_RETURN();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *retval;
+
+	zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C);
+
+	SAVE_OPLINE();
+	retval = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+
+	/* Copy return value into generator->retval */
+	if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+		ZVAL_COPY_VALUE(&generator->retval, retval);
+		if (IS_CV == IS_CONST) {
+			if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) {
+				Z_ADDREF(generator->retval);
+			}
+		}
+	} else if (IS_CV == IS_CV) {
+		ZVAL_COPY_DEREF(&generator->retval, retval);
+	} else /* if (IS_CV == IS_VAR) */ {
+		if (UNEXPECTED(Z_ISREF_P(retval))) {
+			zend_refcounted *ref = Z_COUNTED_P(retval);
+
+			retval = Z_REFVAL_P(retval);
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+			if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+				efree_size(ref, sizeof(zend_reference));
+			} else if (Z_OPT_REFCOUNTED_P(retval)) {
+				Z_ADDREF_P(retval);
+			}
+		} else {
+			ZVAL_COPY_VALUE(&generator->retval, retval);
+		}
+	}
+
+	zend_observer_maybe_fcall_call_end(generator->execute_data, &generator->retval);
+
+	/* Close the generator to free up resources */
+	zend_generator_close(generator, 1);
+
+	/* Pass execution back to handling code */
+	ZEND_VM_RETURN();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -37336,8 +38830,77 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
 	SAVE_OPLINE();
 	inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
 	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
+	if (UNEXPECTED(EG(exception) != NULL)) {
+
+		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
+			destroy_op_array(new_op_array);
+			efree_size(new_op_array, sizeof(zend_op_array));
+		}
+		UNDEF_RESULT();
+		HANDLE_EXCEPTION();
+	} else if (new_op_array == ZEND_FAKE_OP_ARRAY) {
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_TRUE(EX_VAR(opline->result.var));
+		}
+	} else if (EXPECTED(new_op_array != NULL)) {
+		zval *return_value = NULL;
+		zend_execute_data *call;
+
+		if (RETURN_VALUE_USED(opline)) {
+			return_value = EX_VAR(opline->result.var);
+		}
+
+		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,
+			(zend_function*)new_op_array, 0,
+			Z_PTR(EX(This)));
+
+		if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) {
+			call->symbol_table = EX(symbol_table);
+		} else {
+			call->symbol_table = zend_rebuild_symbol_table();
+		}
+
+		call->prev_execute_data = execute_data;
+		i_init_code_execute_data(call, new_op_array, return_value);
+
+		if (EXPECTED(zend_execute_ex == execute_ex)) {
+
+			ZEND_VM_ENTER();
+		} else {
+			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
+			zend_execute_ex(call);
+			zend_vm_stack_free_call_frame(call);
+		}
+
+		destroy_op_array(new_op_array);
+		efree_size(new_op_array, sizeof(zend_op_array));
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_rethrow_exception(execute_data);
 
+			UNDEF_RESULT();
+			HANDLE_EXCEPTION();
+		}
+	} else if (RETURN_VALUE_USED(opline)) {
+		ZVAL_FALSE(EX_VAR(opline->result.var));
+	}
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_op_array *new_op_array;
+	zval *inc_filename;
+
+	SAVE_OPLINE();
+	inc_filename = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC);
+	new_op_array = zend_include_or_eval(inc_filename, opline->extended_value);
 	if (UNEXPECTED(EG(exception) != NULL)) {
+
 		if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) {
 			destroy_op_array(new_op_array);
 			efree_size(new_op_array, sizeof(zend_op_array));
@@ -37371,7 +38934,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
 
 		call->prev_execute_data = execute_data;
 		i_init_code_execute_data(call, new_op_array, return_value);
+		zend_observer_maybe_fcall_call_begin(call);
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+
 			ZEND_VM_ENTER();
 		} else {
 			ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP);
@@ -37383,12 +38948,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLE
 		efree_size(new_op_array, sizeof(zend_op_array));
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			zend_rethrow_exception(execute_data);
+
 			UNDEF_RESULT();
 			HANDLE_EXCEPTION();
 		}
 	} else if (RETURN_VALUE_USED(opline)) {
 		ZVAL_FALSE(EX_VAR(opline->result.var));
 	}
+
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -51443,12 +53010,19 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_LABEL,
 			(void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_LABEL,
 			(void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_LABEL,
+			(void*)&&ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL,
+			(void*)&&ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_LABEL,
 			(void*)&&ZEND_INIT_FCALL_SPEC_CONST_LABEL,
 			(void*)&&ZEND_RETURN_SPEC_CONST_LABEL,
+			(void*)&&ZEND_RETURN_SPEC_CONST_OBSERVER_LABEL,
 			(void*)&&ZEND_RETURN_SPEC_TMP_LABEL,
+			(void*)&&ZEND_RETURN_SPEC_TMP_OBSERVER_LABEL,
 			(void*)&&ZEND_RETURN_SPEC_VAR_LABEL,
+			(void*)&&ZEND_RETURN_SPEC_VAR_OBSERVER_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_RETURN_SPEC_CV_LABEL,
+			(void*)&&ZEND_RETURN_SPEC_CV_OBSERVER_LABEL,
 			(void*)&&ZEND_RECV_SPEC_UNUSED_LABEL,
 			(void*)&&ZEND_RECV_INIT_SPEC_CONST_LABEL,
 			(void*)&&ZEND_SEND_VAL_SPEC_CONST_CONST_LABEL,
@@ -51609,10 +53183,15 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL,
 			(void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL,
 			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL,
+			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_LABEL,
 			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
+			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_LABEL,
 			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL,
+			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL,
+			(void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_LABEL,
 			(void*)&&ZEND_UNSET_VAR_SPEC_CONST_UNUSED_LABEL,
 			(void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
 			(void*)&&ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_LABEL,
@@ -52068,10 +53647,15 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL,
 			(void*)&&ZEND_CLONE_SPEC_CV_LABEL,
 			(void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL,
+			(void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_LABEL,
 			(void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_LABEL,
+			(void*)&&ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_LABEL,
 			(void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_LABEL,
+			(void*)&&ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL,
+			(void*)&&ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_LABEL,
 			(void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL,
 			(void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
 			(void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL,
@@ -52270,8 +53854,12 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_DO_ICALL_SPEC_RETVAL_USED_LABEL,
 			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_LABEL,
 			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_LABEL,
+			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_LABEL,
+			(void*)&&ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_LABEL,
 			(void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_LABEL,
 			(void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_LABEL,
+			(void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_LABEL,
+			(void*)&&ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
@@ -52392,6 +53980,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL,
 			(void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL,
+			(void*)&&ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_LABEL,
 			(void*)&&ZEND_USER_OPCODE_SPEC_LABEL,
 			(void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL,
 			(void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL,
@@ -52414,6 +54003,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL,
 			(void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL,
 			(void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL,
+			(void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL,
 			(void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL,
 			(void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL,
 			(void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL,
@@ -52441,10 +54031,15 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL,
 			(void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL,
 			(void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL,
+			(void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_LABEL,
 			(void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_LABEL,
+			(void*)&&ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_LABEL,
 			(void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_LABEL,
+			(void*)&&ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_LABEL,
+			(void*)&&ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_LABEL,
 			(void*)&&ZEND_FAST_CALL_SPEC_LABEL,
 			(void*)&&ZEND_FAST_RET_SPEC_LABEL,
 			(void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL,
@@ -53741,6 +55336,14 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED)
 				ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER):
+				VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER)
+				ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER):
+				VM_TRACE(ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER)
+				ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED):
 				VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED)
 				ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53749,6 +55352,14 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED)
 				ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER):
+				VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER)
+				ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER):
+				VM_TRACE(ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER)
+				ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED):
 				VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED)
 				ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53757,6 +55368,14 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED)
 				ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER):
+				VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER)
+				ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER):
+				VM_TRACE(ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER)
+				ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_GENERATOR_CREATE_SPEC):
 				VM_TRACE(ZEND_GENERATOR_CREATE_SPEC)
 				ZEND_GENERATOR_CREATE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53829,6 +55448,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC)
 				ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER):
+				VM_TRACE(ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER)
+				ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_USER_OPCODE_SPEC):
 				VM_TRACE(ZEND_USER_OPCODE_SPEC)
 				ZEND_USER_OPCODE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53853,6 +55476,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC)
 				ZEND_CALL_TRAMPOLINE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER):
+				VM_TRACE(ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER)
+				ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_JMP_FORWARD_SPEC):
 				VM_TRACE(ZEND_JMP_FORWARD_SPEC)
 				ZEND_JMP_FORWARD_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -53995,6 +55622,81 @@ zend_leave_helper_SPEC_LABEL:
 			}
 		}
 	}
+
+	goto zend_leave_helper_SPEC_LABEL;
+}
+
+			HYBRID_CASE(ZEND_RETURN_SPEC_CONST_OBSERVER):
+				VM_TRACE(ZEND_RETURN_SPEC_CONST_OBSERVER)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = RT_CONSTANT(opline, opline->op1);
+	return_value = EX(return_value);
+	if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_CONST & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_CONST & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_CONST == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_CONST == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_CONST == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	goto zend_leave_helper_SPEC_LABEL;
 }
 
@@ -54002,10 +55704,18 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST)
 				ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER):
+				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER)
+				ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST):
 				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST)
 				ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER):
+				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER)
+				ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_THROW_SPEC_CONST):
 				VM_TRACE(ZEND_THROW_SPEC_CONST)
 				ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -54034,6 +55744,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST)
 				ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER):
+				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER)
+				ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CONST):
 				VM_TRACE(ZEND_FE_RESET_R_SPEC_CONST)
 				ZEND_FE_RESET_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55134,6 +56848,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR)
 				ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER):
+				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER)
+				ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR):
 				VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR)
 				ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55516,6 +57234,81 @@ zend_leave_helper_SPEC_LABEL:
 			}
 		}
 	}
+
+	goto zend_leave_helper_SPEC_LABEL;
+}
+
+			HYBRID_CASE(ZEND_RETURN_SPEC_TMP_OBSERVER):
+				VM_TRACE(ZEND_RETURN_SPEC_TMP_OBSERVER)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC);
+	return_value = EX(return_value);
+	if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_TMP_VAR == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_TMP_VAR == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_TMP_VAR == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	goto zend_leave_helper_SPEC_LABEL;
 }
 
@@ -55523,10 +57316,18 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP)
 				ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER):
+				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER)
+				ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP):
 				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP)
 				ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER):
+				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER)
+				ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP):
 				VM_TRACE(ZEND_SEND_USER_SPEC_TMP)
 				ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55813,6 +57614,81 @@ zend_leave_helper_SPEC_LABEL:
 			}
 		}
 	}
+
+	goto zend_leave_helper_SPEC_LABEL;
+}
+
+			HYBRID_CASE(ZEND_RETURN_SPEC_VAR_OBSERVER):
+				VM_TRACE(ZEND_RETURN_SPEC_VAR_OBSERVER)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC);
+	return_value = EX(return_value);
+	if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_VAR & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_VAR == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_VAR == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_VAR == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	goto zend_leave_helper_SPEC_LABEL;
 }
 
@@ -55820,10 +57696,18 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR)
 				ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER):
+				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER)
+				ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR):
 				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR)
 				ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER):
+				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER)
+				ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR):
 				VM_TRACE(ZEND_SEND_USER_SPEC_VAR)
 				ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56926,6 +58810,81 @@ zend_leave_helper_SPEC_LABEL:
 			}
 		}
 	}
+
+	goto zend_leave_helper_SPEC_LABEL;
+}
+
+			HYBRID_CASE(ZEND_RETURN_SPEC_CV_OBSERVER):
+				VM_TRACE(ZEND_RETURN_SPEC_CV_OBSERVER)
+{
+	USE_OPLINE
+	zval *retval_ptr;
+	zval *return_value;
+
+	retval_ptr = EX_VAR(opline->op1.var);
+	return_value = EX(return_value);
+	if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) {
+		SAVE_OPLINE();
+		retval_ptr = ZVAL_UNDEFINED_OP1();
+		if (return_value) {
+			ZVAL_NULL(return_value);
+		}
+	} else if (!return_value) {
+		if (IS_CV & (IS_VAR|IS_TMP_VAR)) {
+			if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) {
+				SAVE_OPLINE();
+				rc_dtor_func(Z_COUNTED_P(retval_ptr));
+			}
+		}
+	} else {
+		if ((IS_CV & (IS_CONST|IS_TMP_VAR))) {
+			ZVAL_COPY_VALUE(return_value, retval_ptr);
+			if (IS_CV == IS_CONST) {
+				if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) {
+					Z_ADDREF_P(return_value);
+				}
+			}
+		} else if (IS_CV == IS_CV) {
+			do {
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) {
+						if (EXPECTED(!(EX_CALL_INFO() & ZEND_CALL_CODE))) {
+							zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+							ZVAL_COPY_VALUE(return_value, retval_ptr);
+							if (GC_MAY_LEAK(ref)) {
+								gc_possible_root(ref);
+							}
+							ZVAL_NULL(retval_ptr);
+							break;
+						} else {
+							Z_ADDREF_P(retval_ptr);
+						}
+					} else {
+						retval_ptr = Z_REFVAL_P(retval_ptr);
+						if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+							Z_ADDREF_P(retval_ptr);
+						}
+					}
+				}
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			} while (0);
+		} else /* if (IS_CV == IS_VAR) */ {
+			if (UNEXPECTED(Z_ISREF_P(retval_ptr))) {
+				zend_refcounted *ref = Z_COUNTED_P(retval_ptr);
+
+				retval_ptr = Z_REFVAL_P(retval_ptr);
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+				if (UNEXPECTED(GC_DELREF(ref) == 0)) {
+					efree_size(ref, sizeof(zend_reference));
+				} else if (Z_OPT_REFCOUNTED_P(retval_ptr)) {
+					Z_ADDREF_P(retval_ptr);
+				}
+			} else {
+				ZVAL_COPY_VALUE(return_value, retval_ptr);
+			}
+		}
+	}
+	zend_observer_maybe_fcall_call_end(execute_data, return_value);
 	goto zend_leave_helper_SPEC_LABEL;
 }
 
@@ -56933,10 +58892,18 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV)
 				ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER):
+				VM_TRACE(ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER)
+				ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV):
 				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV)
 				ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER):
+				VM_TRACE(ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER)
+				ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_THROW_SPEC_CV):
 				VM_TRACE(ZEND_THROW_SPEC_CV)
 				ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56961,6 +58928,10 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV)
 				ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER):
+				VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER)
+				ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FE_RESET_R_SPEC_CV):
 				VM_TRACE(ZEND_FE_RESET_R_SPEC_CV)
 				ZEND_FE_RESET_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -57955,7 +59926,11 @@ ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value)
 	}
 	EX(prev_execute_data) = EG(current_execute_data);
 	i_init_code_execute_data(execute_data, op_array, return_value);
+	if (ZEND_OBSERVER_ENABLED) {
+		zend_observer_maybe_fcall_call_begin(execute_data);
+	}
 	zend_execute_ex(execute_data);
+	/* Observer end handlers are called from ZEND_RETURN */
 	zend_vm_stack_free_call_frame(execute_data);
 }
 
@@ -59315,12 +61290,19 @@ void zend_vm_init(void)
 		ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER,
 		ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_HANDLER,
 		ZEND_DO_FCALL_SPEC_RETVAL_USED_HANDLER,
+		ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER,
+		ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER,
 		ZEND_INIT_FCALL_SPEC_CONST_HANDLER,
 		ZEND_RETURN_SPEC_CONST_HANDLER,
+		ZEND_RETURN_SPEC_CONST_OBSERVER_HANDLER,
 		ZEND_RETURN_SPEC_TMP_HANDLER,
+		ZEND_RETURN_SPEC_TMP_OBSERVER_HANDLER,
 		ZEND_RETURN_SPEC_VAR_HANDLER,
+		ZEND_RETURN_SPEC_VAR_OBSERVER_HANDLER,
+		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_RETURN_SPEC_CV_HANDLER,
+		ZEND_RETURN_SPEC_CV_OBSERVER_HANDLER,
 		ZEND_RECV_SPEC_UNUSED_HANDLER,
 		ZEND_RECV_INIT_SPEC_CONST_HANDLER,
 		ZEND_SEND_VAL_SPEC_CONST_CONST_HANDLER,
@@ -59481,10 +61463,15 @@ void zend_vm_init(void)
 		ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER,
 		ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER,
 		ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER,
+		ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER_HANDLER,
 		ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
+		ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER,
 		ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER,
+		ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER_HANDLER,
+		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
+		ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER_HANDLER,
 		ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
 		ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
 		ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER,
@@ -59940,10 +61927,15 @@ void zend_vm_init(void)
 		ZEND_CLONE_SPEC_UNUSED_HANDLER,
 		ZEND_CLONE_SPEC_CV_HANDLER,
 		ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER,
+		ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER_HANDLER,
 		ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER,
+		ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER_HANDLER,
 		ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER,
+		ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER_HANDLER,
+		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_RETURN_BY_REF_SPEC_CV_HANDLER,
+		ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER_HANDLER,
 		ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER,
 		ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
 		ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER,
@@ -60142,8 +62134,12 @@ void zend_vm_init(void)
 		ZEND_DO_ICALL_SPEC_RETVAL_USED_HANDLER,
 		ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER,
 		ZEND_DO_UCALL_SPEC_RETVAL_USED_HANDLER,
+		ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER,
+		ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER_HANDLER,
 		ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_HANDLER,
 		ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_HANDLER,
+		ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER_HANDLER,
+		ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
@@ -60264,6 +62260,7 @@ void zend_vm_init(void)
 		ZEND_NULL_HANDLER,
 		ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER,
 		ZEND_HANDLE_EXCEPTION_SPEC_HANDLER,
+		ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER_HANDLER,
 		ZEND_USER_OPCODE_SPEC_HANDLER,
 		ZEND_ASSERT_CHECK_SPEC_HANDLER,
 		ZEND_JMP_SET_SPEC_CONST_HANDLER,
@@ -60286,6 +62283,7 @@ void zend_vm_init(void)
 		ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER,
 		ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER,
 		ZEND_CALL_TRAMPOLINE_SPEC_HANDLER,
+		ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER,
 		ZEND_DISCARD_EXCEPTION_SPEC_HANDLER,
 		ZEND_YIELD_SPEC_CONST_CONST_HANDLER,
 		ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER,
@@ -60313,10 +62311,15 @@ void zend_vm_init(void)
 		ZEND_YIELD_SPEC_CV_UNUSED_HANDLER,
 		ZEND_YIELD_SPEC_CV_CV_HANDLER,
 		ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER,
+		ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER_HANDLER,
 		ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER,
+		ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER_HANDLER,
 		ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER,
+		ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER_HANDLER,
+		ZEND_NULL_HANDLER,
 		ZEND_NULL_HANDLER,
 		ZEND_GENERATOR_RETURN_SPEC_CV_HANDLER,
+		ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER_HANDLER,
 		ZEND_FAST_CALL_SPEC_HANDLER,
 		ZEND_FAST_RET_SPEC_HANDLER,
 		ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER,
@@ -61449,147 +63452,147 @@ void zend_vm_init(void)
 		1347,
 		1348,
 		1349,
-		1350 | SPEC_RULE_RETVAL,
-		1352,
-		1353 | SPEC_RULE_OP1,
-		1358,
-		1359,
-		1360 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1385 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
-		1435 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1460 | SPEC_RULE_OP1,
-		1465,
-		1466,
-		1467 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1492 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1517 | SPEC_RULE_OP1,
-		1522 | SPEC_RULE_OP1,
-		1527 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1552 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1577 | SPEC_RULE_OP1,
-		1582,
-		1583,
-		1584 | SPEC_RULE_OP1,
-		1589 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1614 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1639 | SPEC_RULE_OP1,
-		1644 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1669 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1694 | SPEC_RULE_OP1,
-		1699 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1724 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1749 | SPEC_RULE_OP1,
-		1754 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1779 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1804 | SPEC_RULE_OP1,
-		1809 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1834 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1859 | SPEC_RULE_OP1,
-		1864 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1889 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1914 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		1939,
-		1940 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
-		1950,
+		1350 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		1354,
+		1355 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
+		1365,
+		1366,
+		1367 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1392 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
+		1442 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1467 | SPEC_RULE_OP1,
+		1472,
+		1473,
+		1474 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1499 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1524 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
+		1534 | SPEC_RULE_OP1,
+		1539 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1564 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1589 | SPEC_RULE_OP1,
+		1594,
+		1595,
+		1596 | SPEC_RULE_OP1,
+		1601 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1626 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1651 | SPEC_RULE_OP1,
+		1656 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1681 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1706 | SPEC_RULE_OP1,
+		1711 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1736 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1761 | SPEC_RULE_OP1,
+		1766 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1791 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1816 | SPEC_RULE_OP1,
+		1821 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1846 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1871 | SPEC_RULE_OP1,
+		1876 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1901 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		1926 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1951,
-		1952,
-		1953,
-		1954,
-		1955 | SPEC_RULE_OP2,
-		1960,
-		1961 | SPEC_RULE_OP1,
-		1966 | SPEC_RULE_OP2,
-		1971 | SPEC_RULE_OP1,
-		1976 | SPEC_RULE_OP1,
-		1981 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2006 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2031 | SPEC_RULE_OP1,
-		2036 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2061 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
-		2111 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2136 | SPEC_RULE_OP2,
-		2141,
-		2142 | SPEC_RULE_OP1,
-		2147 | SPEC_RULE_OP1,
-		2152,
-		2153 | SPEC_RULE_OP1,
-		2158 | SPEC_RULE_OP1,
-		2163 | SPEC_RULE_OP1,
-		2168,
+		1952 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
+		1962,
+		1963,
+		1964,
+		1965,
+		1966,
+		1967 | SPEC_RULE_OP2,
+		1972,
+		1973 | SPEC_RULE_OP1,
+		1978 | SPEC_RULE_OP2,
+		1983 | SPEC_RULE_OP1,
+		1988 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
+		1998 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2023 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2048 | SPEC_RULE_OP1,
+		2053 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2078 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_QUICK_ARG,
+		2128 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2153 | SPEC_RULE_OP2,
+		2158,
+		2159 | SPEC_RULE_OP1,
+		2164 | SPEC_RULE_OP1,
 		2169,
-		2170 | SPEC_RULE_OP2,
-		2175 | SPEC_RULE_RETVAL,
-		2177 | SPEC_RULE_RETVAL,
-		2179 | SPEC_RULE_RETVAL,
-		2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2181 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2206 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2231 | SPEC_RULE_OP1,
-		2236,
-		2237 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2262,
-		2263 | SPEC_RULE_OP1,
-		2268,
-		2269,
-		2270,
-		2271,
-		2272,
-		2273,
-		2274,
-		2275 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2300,
-		2301,
-		2302,
-		2303 | SPEC_RULE_OP1,
-		2308,
-		2309 | SPEC_RULE_ISSET,
-		2311 | SPEC_RULE_OP2,
-		2316,
-		2317 | SPEC_RULE_OP1,
-		2322,
+		2170 | SPEC_RULE_OP1,
+		2175 | SPEC_RULE_OP1,
+		2180 | SPEC_RULE_OP1,
+		2185,
+		2186,
+		2187 | SPEC_RULE_OP2,
+		2192 | SPEC_RULE_RETVAL,
+		2194 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		2198 | SPEC_RULE_RETVAL | SPEC_RULE_OBSERVER,
+		2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2202 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2227 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2252 | SPEC_RULE_OP1,
+		2257,
+		2258 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2283,
+		2284 | SPEC_RULE_OP1,
+		2289,
+		2290,
+		2291,
+		2292,
+		2293,
+		2294,
+		2295,
+		2296 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2321 | SPEC_RULE_OBSERVER,
 		2323,
-		2324 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2349 | SPEC_RULE_OP1,
-		2354,
-		2355,
-		2356,
-		2357,
-		2358 | SPEC_RULE_OP1,
-		2363,
-		2364,
-		2365 | SPEC_RULE_OP1,
-		2370 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2395,
-		2396 | SPEC_RULE_OP1,
-		2401,
-		2402,
-		2403,
-		2404,
-		2405,
-		2406,
-		2407,
-		2408,
-		2409 | SPEC_RULE_OP1,
-		2414,
-		2415,
-		2416,
-		2417 | SPEC_RULE_OP2,
-		2422,
-		2423 | SPEC_RULE_OP1,
-		2428 | SPEC_RULE_OP1,
-		2433 | SPEC_RULE_OP1,
-		2438 | SPEC_RULE_OP1,
-		2443 | SPEC_RULE_OP1,
-		2448,
-		2449 | SPEC_RULE_OP1,
-		2454 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2479 | SPEC_RULE_OP1,
-		2484 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
-		2509 | SPEC_RULE_OP1,
-		2514 | SPEC_RULE_OP1,
-		2519,
-		3423
+		2324,
+		2325 | SPEC_RULE_OP1,
+		2330,
+		2331 | SPEC_RULE_ISSET,
+		2333 | SPEC_RULE_OP2,
+		2338,
+		2339 | SPEC_RULE_OP1,
+		2344 | SPEC_RULE_OBSERVER,
+		2346,
+		2347 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2372 | SPEC_RULE_OP1 | SPEC_RULE_OBSERVER,
+		2382,
+		2383,
+		2384,
+		2385,
+		2386 | SPEC_RULE_OP1,
+		2391,
+		2392,
+		2393 | SPEC_RULE_OP1,
+		2398 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2423,
+		2424 | SPEC_RULE_OP1,
+		2429,
+		2430,
+		2431,
+		2432,
+		2433,
+		2434,
+		2435,
+		2436,
+		2437 | SPEC_RULE_OP1,
+		2442,
+		2443,
+		2444,
+		2445 | SPEC_RULE_OP2,
+		2450,
+		2451 | SPEC_RULE_OP1,
+		2456 | SPEC_RULE_OP1,
+		2461 | SPEC_RULE_OP1,
+		2466 | SPEC_RULE_OP1,
+		2471 | SPEC_RULE_OP1,
+		2476,
+		2477 | SPEC_RULE_OP1,
+		2482 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2507 | SPEC_RULE_OP1,
+		2512 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+		2537 | SPEC_RULE_OP1,
+		2542 | SPEC_RULE_OP1,
+		2547,
+		3451
 	};
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
 	zend_opcode_handler_funcs = labels;
@@ -61698,6 +63701,9 @@ static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, cons
 	if (spec & SPEC_EXTRA_MASK) {
 		if (spec & SPEC_RULE_RETVAL) {
 			offset = offset * 2 + (op->result_type != IS_UNUSED);
+			if ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {
+				offset += 2;
+			}
 		} else if (spec & SPEC_RULE_QUICK_ARG) {
 			offset = offset * 2 + (op->op2.num <= MAX_ARG_FLAG_NUM);
 		} else if (spec & SPEC_RULE_OP_DATA) {
@@ -61711,6 +63717,11 @@ static uint32_t ZEND_FASTCALL zend_vm_get_opcode_handler_idx(uint32_t spec, cons
 			} else if (op->result_type == (IS_SMART_BRANCH_JMPNZ|IS_TMP_VAR)) {
 				offset += 2;
 			}
+		} else if (spec & SPEC_RULE_OBSERVER) {
+			offset = offset * 2;
+			if (ZEND_OBSERVER_ENABLED) {
+				offset += 1;
+			}
 		}
 	}
 	return (spec & SPEC_START_MASK) + offset;
@@ -61754,7 +63765,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 = 2522 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2550 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -61762,7 +63773,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 = 2575 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -61770,7 +63781,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 = 2600 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -61781,17 +63792,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 = 2597 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2625 | 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 = 2622 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2650 | 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 = 2647 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2675 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_MUL:
@@ -61802,17 +63813,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 = 2672 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2700 | 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 = 2697 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2725 | 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 = 2722 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2750 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_IDENTICAL:
@@ -61823,14 +63834,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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2775 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2850 | 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 = 3047 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3075 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_IDENTICAL:
@@ -61841,14 +63852,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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2925 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3000 | 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 = 3052 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3080 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_EQUAL:
@@ -61859,12 +63870,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 = 2747 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2775 | 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 = 2822 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2850 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_EQUAL:
@@ -61875,12 +63886,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 = 2897 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2925 | 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 = 2972 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3000 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_SMALLER:
@@ -61888,12 +63899,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 = 3057 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3085 | 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 = 3132 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3160 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
@@ -61901,74 +63912,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 = 3207 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3235 | 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 = 3282 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3310 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_QM_ASSIGN:
 			if (op1_info == MAY_BE_LONG) {
-				spec = 3369 | SPEC_RULE_OP1;
+				spec = 3397 | SPEC_RULE_OP1;
 			} else if (op1_info == MAY_BE_DOUBLE) {
-				spec = 3374 | SPEC_RULE_OP1;
+				spec = 3402 | 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 = 3379 | SPEC_RULE_OP1;
+				spec = 3407 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_PRE_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3357 | SPEC_RULE_RETVAL;
+				spec = 3385 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3359 | SPEC_RULE_RETVAL;
+				spec = 3387 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_PRE_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3361 | SPEC_RULE_RETVAL;
+				spec = 3389 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3363 | SPEC_RULE_RETVAL;
+				spec = 3391 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_POST_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3365;
+				spec = 3393;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3366;
+				spec = 3394;
 			}
 			break;
 		case ZEND_POST_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3367;
+				spec = 3395;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3368;
+				spec = 3396;
 			}
 			break;
 		case ZEND_JMP:
 			if (OP_JMP_ADDR(op, op->op1) > op) {
-				spec = 2521;
+				spec = 2549;
 			}
 			break;
 		case ZEND_RECV:
 			if (op->op2.num == MAY_BE_ANY) {
-				spec = 2520;
+				spec = 2548;
 			}
 			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 = 3419;
+				spec = 3447;
 			}
 			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 = 3414 | SPEC_RULE_OP1;
+				spec = 3442 | 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 = 3421 | SPEC_RULE_RETVAL;
+				spec = 3449 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_FETCH_DIM_R:
@@ -61976,17 +63987,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 = 3384 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 3412 | 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 = 3420;
+				spec = 3448;
 			}
 			break;
 		case ZEND_SEND_VAR:
 			if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3409 | SPEC_RULE_OP1;
+				spec = 3437 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_BW_OR:
diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl
index fcd52aba9c..22911760e4 100644
--- a/Zend/zend_vm_execute.skl
+++ b/Zend/zend_vm_execute.skl
@@ -55,7 +55,11 @@ ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value
 	}
 	EX(prev_execute_data) = EG(current_execute_data);
 	i_init_code_execute_data(execute_data, op_array, return_value);
+	if (ZEND_OBSERVER_ENABLED) {
+		zend_observer_maybe_fcall_call_begin(execute_data);
+	}
 	zend_{%EXECUTOR_NAME%}_ex(execute_data);
+	/* Observer end handlers are called from ZEND_RETURN */
 	zend_vm_stack_free_call_frame(execute_data);
 }
 
diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index d05c278c17..2c2a64b294 100755
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -793,6 +793,12 @@ function gen_code($f, $spec, $kind, $code, $op1, $op2, $name, $extra_spec=null)
         "/opline->extended_value\s*&\s*~\s*ZEND_ISEMPTY/" => isset($extra_spec['ISSET']) ?
             ($extra_spec['ISSET'] == 0 ? "\\0" : "opline->extended_value")
             : "\\0",
+        "/OBSERVER_FCALL_BEGIN_HANDLERS\(\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ?
+            ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_begin(\\1)")
+            : "",
+        "/OBSERVER_FCALL_END_HANDLERS\(\s*([^,]*)\s*,\s*(.*)\s*\)/" => isset($extra_spec['OBSERVER']) ?
+            ($extra_spec['OBSERVER'] == 0 ? "" : "zend_observer_maybe_fcall_call_end(\\1, \\2)")
+            : "",
     );
     $code = preg_replace(array_keys($specialized_replacements), array_values($specialized_replacements), $code);
 
@@ -952,6 +958,9 @@ function is_hot_handler($hot, $op1, $op2, $extra_spec) {
     if (isset($extra_spec["SMART_BRANCH"]) && $extra_spec["SMART_BRANCH"] == 0) {
         return false;
     }
+    if (isset($extra_spec["OBSERVER"]) && $extra_spec["OBSERVER"] == 1) {
+        return false;
+    }
     if ($hot === 'HOT_' || $hot === 'INLINE_') {
         return true;
     } else if ($hot === 'HOT_NOCONST_') {
@@ -970,6 +979,8 @@ function is_hot_handler($hot, $op1, $op2, $extra_spec) {
 function is_cold_handler($hot, $op1, $op2, $extra_spec) {
     if ($hot === 'COLD_') {
         return true;
+    } else if (isset($extra_spec["OBSERVER"]) && $extra_spec["OBSERVER"] == 1) {
+        return true;
     } else if ($hot === 'COLD_CONST_') {
         return ($op1 === 'CONST');
     } else if ($hot === 'COLD_CONSTCONST_') {
@@ -1550,6 +1561,11 @@ function extra_spec_name($extra_spec) {
             $s .= "_EMPTY";
         }
     }
+    if (isset($extra_spec["OBSERVER"])) {
+        if ($extra_spec["OBSERVER"]) {
+            $s .= "_OBSERVER";
+        }
+    }
     return $s;
 }
 
@@ -1573,6 +1589,9 @@ function extra_spec_flags($extra_spec) {
     if (isset($extra_spec["ISSET"])) {
         $s[] = "SPEC_RULE_ISSET";
     }
+    if (isset($extra_spec["OBSERVER"])) {
+        $s[] = "SPEC_RULE_OBSERVER";
+    }
     return $s;
 }
 
@@ -1771,6 +1790,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name)
                     out($f,"#define SPEC_RULE_SMART_BRANCH 0x00200000\n");
                     out($f,"#define SPEC_RULE_COMMUTATIVE  0x00800000\n");
                     out($f,"#define SPEC_RULE_ISSET        0x01000000\n");
+                    out($f,"#define SPEC_RULE_OBSERVER     0x02000000\n");
                     out($f,"\n");
                     out($f,"static const uint32_t *zend_spec_handlers;\n");
                     out($f,"static const void * const *zend_opcode_handlers;\n");
@@ -2247,6 +2267,9 @@ function parse_spec_rules($def, $lineno, $str) {
                 case "ISSET":
                     $ret["ISSET"] = array(0, 1);
                     break;
+                case "OBSERVER":
+                    $ret["OBSERVER"] = array(0, 1);
+                    break;
                 default:
                     die("ERROR ($def:$lineno): Wrong specialization rules '$str'\n");
             }
@@ -2653,7 +2676,8 @@ function gen_vm($def, $skel) {
             isset($used_extra_spec["RETVAL"]) ||
             isset($used_extra_spec["QUICK_ARG"]) ||
             isset($used_extra_spec["SMART_BRANCH"]) ||
-            isset($used_extra_spec["ISSET"])) {
+            isset($used_extra_spec["ISSET"]) ||
+            isset($used_extra_spec["OBSERVER"])) {
 
             $else = "";
             out($f, "\tif (spec & SPEC_EXTRA_MASK) {\n");
@@ -2661,6 +2685,9 @@ function gen_vm($def, $skel) {
             if (isset($used_extra_spec["RETVAL"])) {
                 out($f, "\t\t{$else}if (spec & SPEC_RULE_RETVAL) {\n");
                 out($f, "\t\t\toffset = offset * 2 + (op->result_type != IS_UNUSED);\n");
+                out($f, "\t\t\tif ((spec & SPEC_RULE_OBSERVER) && ZEND_OBSERVER_ENABLED) {\n");
+                out($f,	"\t\t\t\toffset += 2;\n");
+                out($f, "\t\t\t}\n");
                 $else = "} else ";
             }
             if (isset($used_extra_spec["QUICK_ARG"])) {
@@ -2688,6 +2715,14 @@ function gen_vm($def, $skel) {
                 out($f, "\t\t\t}\n");
                 $else = "} else ";
             }
+            if (isset($used_extra_spec["OBSERVER"])) {
+                out($f, "\t\t{$else}if (spec & SPEC_RULE_OBSERVER) {\n");
+                out($f,	"\t\t\toffset = offset * 2;\n");
+                out($f, "\t\t\tif (ZEND_OBSERVER_ENABLED) {\n");
+                out($f,	"\t\t\t\toffset += 1;\n");
+                out($f, "\t\t\t}\n");
+                $else = "} else ";
+            }
             if ($else !== "") {
                 out($f, "\t\t}\n");
             }
diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index afcc07a8fd..8410c70e15 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -637,1190 +637,1214 @@
 	_(1349, ZEND_INIT_FCALL_BY_NAME_SPEC_CONST) \
 	_(1350, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED) \
 	_(1351, ZEND_DO_FCALL_SPEC_RETVAL_USED) \
-	_(1352, ZEND_INIT_FCALL_SPEC_CONST) \
-	_(1353, ZEND_RETURN_SPEC_CONST) \
-	_(1354, ZEND_RETURN_SPEC_TMP) \
-	_(1355, ZEND_RETURN_SPEC_VAR) \
-	_(1357, ZEND_RETURN_SPEC_CV) \
-	_(1358, ZEND_RECV_SPEC_UNUSED) \
-	_(1359, ZEND_RECV_INIT_SPEC_CONST) \
-	_(1360, ZEND_SEND_VAL_SPEC_CONST_CONST) \
-	_(1363, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \
-	_(1365, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \
-	_(1368, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \
-	_(1370, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \
-	_(1373, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \
-	_(1405, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \
-	_(1406, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \
-	_(1411, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \
-	_(1412, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \
-	_(1425, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \
-	_(1426, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \
-	_(1431, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \
-	_(1432, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \
-	_(1445, ZEND_SEND_REF_SPEC_VAR_CONST) \
-	_(1448, ZEND_SEND_REF_SPEC_VAR_UNUSED) \
-	_(1455, ZEND_SEND_REF_SPEC_CV_CONST) \
-	_(1458, ZEND_SEND_REF_SPEC_CV_UNUSED) \
-	_(1460, ZEND_NEW_SPEC_CONST_UNUSED) \
-	_(1462, ZEND_NEW_SPEC_VAR_UNUSED) \
-	_(1463, ZEND_NEW_SPEC_UNUSED_UNUSED) \
-	_(1465, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \
-	_(1466, ZEND_FREE_SPEC_TMPVAR) \
-	_(1467, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \
-	_(1468, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
-	_(1469, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
-	_(1470, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \
-	_(1471, ZEND_INIT_ARRAY_SPEC_CONST_CV) \
-	_(1472, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \
-	_(1473, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
-	_(1474, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
-	_(1475, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \
-	_(1476, ZEND_INIT_ARRAY_SPEC_TMP_CV) \
-	_(1477, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \
-	_(1478, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
-	_(1479, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
-	_(1480, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
-	_(1481, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
-	_(1482, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \
-	_(1483, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
-	_(1484, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
-	_(1485, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \
-	_(1486, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \
-	_(1487, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
-	_(1488, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
-	_(1489, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
-	_(1490, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \
-	_(1491, ZEND_INIT_ARRAY_SPEC_CV_CV) \
-	_(1492, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \
-	_(1493, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
-	_(1494, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
-	_(1495, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \
-	_(1496, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \
-	_(1497, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \
-	_(1498, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
-	_(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
-	_(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \
-	_(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \
-	_(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \
-	_(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
-	_(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
-	_(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \
-	_(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \
-	_(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \
-	_(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
-	_(1514, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
-	_(1515, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \
-	_(1516, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \
-	_(1517, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \
-	_(1518, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
-	_(1519, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
-	_(1521, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \
-	_(1522, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \
-	_(1523, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
-	_(1524, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
-	_(1526, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \
-	_(1537, ZEND_UNSET_DIM_SPEC_VAR_CONST) \
-	_(1538, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
-	_(1539, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
-	_(1541, ZEND_UNSET_DIM_SPEC_VAR_CV) \
-	_(1547, ZEND_UNSET_DIM_SPEC_CV_CONST) \
-	_(1548, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
-	_(1549, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
-	_(1551, ZEND_UNSET_DIM_SPEC_CV_CV) \
-	_(1562, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \
-	_(1563, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
-	_(1564, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
-	_(1566, ZEND_UNSET_OBJ_SPEC_VAR_CV) \
-	_(1567, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \
-	_(1568, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(1569, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(1571, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \
-	_(1572, ZEND_UNSET_OBJ_SPEC_CV_CONST) \
-	_(1573, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
-	_(1574, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
-	_(1576, ZEND_UNSET_OBJ_SPEC_CV_CV) \
-	_(1577, ZEND_FE_RESET_R_SPEC_CONST) \
-	_(1578, ZEND_FE_RESET_R_SPEC_TMP) \
-	_(1579, ZEND_FE_RESET_R_SPEC_VAR) \
-	_(1581, ZEND_FE_RESET_R_SPEC_CV) \
-	_(1582, ZEND_FE_FETCH_R_SPEC_VAR) \
-	_(1583, ZEND_EXIT_SPEC) \
-	_(1584, ZEND_FETCH_R_SPEC_CONST_UNUSED) \
-	_(1585, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
-	_(1586, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
-	_(1588, ZEND_FETCH_R_SPEC_CV_UNUSED) \
-	_(1589, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \
-	_(1590, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
-	_(1591, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
-	_(1593, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \
-	_(1594, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
-	_(1595, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-	_(1596, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-	_(1598, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
-	_(1599, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
-	_(1600, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-	_(1601, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
-	_(1603, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
-	_(1609, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \
-	_(1610, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
-	_(1611, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
-	_(1613, ZEND_FETCH_DIM_R_SPEC_CV_CV) \
-	_(1614, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \
-	_(1615, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
-	_(1616, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
-	_(1618, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \
-	_(1619, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
-	_(1620, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-	_(1621, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-	_(1623, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
-	_(1624, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
-	_(1625, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-	_(1626, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
-	_(1628, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
-	_(1629, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \
-	_(1630, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
-	_(1631, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
-	_(1633, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \
-	_(1634, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \
-	_(1635, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
-	_(1636, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
-	_(1638, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \
-	_(1639, ZEND_FETCH_W_SPEC_CONST_UNUSED) \
-	_(1640, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
-	_(1641, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
-	_(1643, ZEND_FETCH_W_SPEC_CV_UNUSED) \
-	_(1654, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \
-	_(1655, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
-	_(1656, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
-	_(1657, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \
-	_(1658, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \
-	_(1664, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \
-	_(1665, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
-	_(1666, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
-	_(1667, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \
-	_(1668, ZEND_FETCH_DIM_W_SPEC_CV_CV) \
-	_(1679, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \
-	_(1680, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
-	_(1681, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
-	_(1683, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \
-	_(1684, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \
-	_(1685, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
-	_(1686, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
-	_(1688, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \
-	_(1689, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \
-	_(1690, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
-	_(1691, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
-	_(1693, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \
-	_(1694, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \
-	_(1695, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
-	_(1696, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
-	_(1698, ZEND_FETCH_RW_SPEC_CV_UNUSED) \
-	_(1709, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \
-	_(1710, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
-	_(1711, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
-	_(1712, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \
-	_(1713, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \
-	_(1719, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \
-	_(1720, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
-	_(1721, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
-	_(1722, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \
-	_(1723, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \
-	_(1734, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \
-	_(1735, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
-	_(1736, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
-	_(1738, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \
-	_(1739, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \
-	_(1740, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
-	_(1741, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
-	_(1743, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \
-	_(1744, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \
-	_(1745, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
-	_(1746, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
-	_(1748, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \
-	_(1749, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \
-	_(1750, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
-	_(1751, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
-	_(1753, ZEND_FETCH_IS_SPEC_CV_UNUSED) \
-	_(1754, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \
-	_(1755, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
-	_(1756, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
-	_(1758, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \
-	_(1759, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
-	_(1760, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1761, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1763, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
-	_(1764, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
-	_(1765, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1766, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1768, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
-	_(1774, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \
-	_(1775, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
-	_(1776, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
-	_(1778, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \
-	_(1779, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \
-	_(1780, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
-	_(1781, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
-	_(1783, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \
-	_(1784, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
-	_(1785, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1786, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1788, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
-	_(1789, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
-	_(1790, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1791, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
-	_(1793, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
-	_(1794, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \
-	_(1795, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
-	_(1796, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
-	_(1798, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \
-	_(1799, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \
-	_(1800, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
-	_(1801, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
-	_(1803, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \
-	_(1804, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \
-	_(1805, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-	_(1806, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
-	_(1808, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \
-	_(1809, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \
-	_(1810, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
-	_(1811, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
-	_(1812, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \
-	_(1813, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \
-	_(1814, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \
-	_(1815, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
-	_(1816, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
-	_(1817, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \
-	_(1818, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \
-	_(1819, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \
-	_(1820, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
-	_(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
-	_(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \
-	_(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \
-	_(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \
-	_(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
-	_(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
-	_(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \
-	_(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \
-	_(1834, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \
-	_(1835, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
-	_(1836, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
-	_(1838, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \
-	_(1839, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \
-	_(1840, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
-	_(1841, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
-	_(1843, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \
-	_(1844, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \
-	_(1845, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
-	_(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
-	_(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \
-	_(1849, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \
-	_(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
-	_(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
-	_(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \
-	_(1854, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \
-	_(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
-	_(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
-	_(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \
-	_(1859, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \
-	_(1860, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
-	_(1861, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
-	_(1863, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \
-	_(1874, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \
-	_(1875, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
-	_(1876, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
-	_(1878, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \
-	_(1884, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \
-	_(1885, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
-	_(1886, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
-	_(1888, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \
-	_(1899, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \
-	_(1900, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
-	_(1901, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
-	_(1903, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \
-	_(1904, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \
-	_(1905, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
-	_(1906, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
-	_(1908, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \
-	_(1909, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \
-	_(1910, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
-	_(1911, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
-	_(1913, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \
-	_(1914, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \
-	_(1915, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
-	_(1916, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
-	_(1918, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \
-	_(1919, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-	_(1920, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1921, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1923, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-	_(1924, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-	_(1925, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1926, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1928, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-	_(1934, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
-	_(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
-	_(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
-	_(1939, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \
-	_(1940, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \
-	_(1941, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \
-	_(1946, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \
-	_(1947, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \
-	_(1950, ZEND_EXT_STMT_SPEC) \
-	_(1951, ZEND_EXT_FCALL_BEGIN_SPEC) \
-	_(1952, ZEND_EXT_FCALL_END_SPEC) \
-	_(1953, ZEND_EXT_NOP_SPEC) \
-	_(1954, ZEND_TICKS_SPEC) \
-	_(1955, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \
-	_(1958, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \
-	_(1960, ZEND_CATCH_SPEC_CONST) \
-	_(1961, ZEND_THROW_SPEC_CONST) \
-	_(1962, ZEND_THROW_SPEC_TMPVAR) \
-	_(1963, ZEND_THROW_SPEC_TMPVAR) \
-	_(1965, ZEND_THROW_SPEC_CV) \
-	_(1966, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \
-	_(1967, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
-	_(1968, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
-	_(1969, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \
-	_(1970, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \
-	_(1971, ZEND_CLONE_SPEC_CONST) \
-	_(1972, ZEND_CLONE_SPEC_TMPVAR) \
-	_(1973, ZEND_CLONE_SPEC_TMPVAR) \
-	_(1974, ZEND_CLONE_SPEC_UNUSED) \
-	_(1975, ZEND_CLONE_SPEC_CV) \
-	_(1976, ZEND_RETURN_BY_REF_SPEC_CONST) \
-	_(1977, ZEND_RETURN_BY_REF_SPEC_TMP) \
-	_(1978, ZEND_RETURN_BY_REF_SPEC_VAR) \
-	_(1980, ZEND_RETURN_BY_REF_SPEC_CV) \
-	_(1981, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \
-	_(1982, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
-	_(1983, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
-	_(1985, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \
-	_(1986, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
-	_(1987, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-	_(1988, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-	_(1990, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
-	_(1991, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
-	_(1992, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-	_(1993, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
-	_(1995, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
-	_(1996, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \
-	_(1997, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-	_(1998, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-	_(2000, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \
-	_(2001, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \
-	_(2002, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
-	_(2003, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
-	_(2005, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \
-	_(2006, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \
-	_(2007, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
-	_(2008, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
-	_(2009, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \
-	_(2010, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \
-	_(2016, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \
-	_(2017, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
-	_(2018, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
-	_(2019, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \
-	_(2020, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \
-	_(2021, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \
-	_(2022, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-	_(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
-	_(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \
-	_(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \
-	_(2031, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \
-	_(2032, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
-	_(2033, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
-	_(2035, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \
-	_(2036, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \
-	_(2037, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
-	_(2038, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
-	_(2040, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \
-	_(2041, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
-	_(2042, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2043, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2045, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
-	_(2046, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
-	_(2047, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2048, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2050, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
-	_(2056, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \
-	_(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
-	_(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
-	_(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \
-	_(2061, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \
-	_(2062, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \
-	_(2067, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \
-	_(2068, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \
-	_(2071, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \
-	_(2072, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \
-	_(2077, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \
-	_(2078, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \
-	_(2121, ZEND_SEND_VAR_SPEC_VAR_CONST) \
-	_(2124, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \
-	_(2131, ZEND_SEND_VAR_SPEC_CV_CONST) \
-	_(2134, ZEND_SEND_VAR_SPEC_CV_UNUSED) \
-	_(2136, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \
-	_(2137, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
-	_(2138, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
-	_(2140, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \
-	_(2141, ZEND_SEND_ARRAY_SPEC) \
-	_(2142, ZEND_SEND_USER_SPEC_CONST) \
-	_(2143, ZEND_SEND_USER_SPEC_TMP) \
-	_(2144, ZEND_SEND_USER_SPEC_VAR) \
-	_(2146, ZEND_SEND_USER_SPEC_CV) \
-	_(2147, ZEND_STRLEN_SPEC_CONST) \
-	_(2148, ZEND_STRLEN_SPEC_TMPVAR) \
-	_(2149, ZEND_STRLEN_SPEC_TMPVAR) \
-	_(2151, ZEND_STRLEN_SPEC_CV) \
-	_(2152, ZEND_DEFINED_SPEC_CONST) \
-	_(2153, ZEND_TYPE_CHECK_SPEC_CONST) \
-	_(2154, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
-	_(2155, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
-	_(2157, ZEND_TYPE_CHECK_SPEC_CV) \
-	_(2158, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \
-	_(2159, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \
-	_(2160, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \
-	_(2161, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \
-	_(2162, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \
-	_(2163, ZEND_FE_RESET_RW_SPEC_CONST) \
-	_(2164, ZEND_FE_RESET_RW_SPEC_TMP) \
-	_(2165, ZEND_FE_RESET_RW_SPEC_VAR) \
-	_(2167, ZEND_FE_RESET_RW_SPEC_CV) \
-	_(2168, ZEND_FE_FETCH_RW_SPEC_VAR) \
-	_(2169, ZEND_FE_FREE_SPEC_TMPVAR) \
-	_(2170, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \
-	_(2171, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
-	_(2172, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
-	_(2174, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
-	_(2175, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
-	_(2176, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
-	_(2177, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
-	_(2178, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
-	_(2179, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
-	_(2180, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
-	_(2191, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
-	_(2192, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2193, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2195, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
-	_(2196, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
-	_(2197, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2198, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2200, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
-	_(2201, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
-	_(2202, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2203, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2205, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
-	_(2216, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
-	_(2217, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2218, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
-	_(2220, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
-	_(2221, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
-	_(2222, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2223, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2225, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
-	_(2226, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
-	_(2227, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2228, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
-	_(2230, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
-	_(2231, ZEND_ECHO_SPEC_CONST) \
-	_(2232, ZEND_ECHO_SPEC_TMPVAR) \
-	_(2233, ZEND_ECHO_SPEC_TMPVAR) \
-	_(2235, ZEND_ECHO_SPEC_CV) \
-	_(2242, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-	_(2244, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-	_(2245, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-	_(2247, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
-	_(2249, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
-	_(2250, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
-	_(2257, ZEND_INSTANCEOF_SPEC_CV_CONST) \
-	_(2259, ZEND_INSTANCEOF_SPEC_CV_VAR) \
-	_(2260, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
-	_(2262, ZEND_GENERATOR_CREATE_SPEC) \
-	_(2265, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
-	_(2267, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
-	_(2268, ZEND_DECLARE_FUNCTION_SPEC) \
-	_(2269, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
-	_(2270, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
-	_(2271, ZEND_DECLARE_CLASS_SPEC_CONST) \
-	_(2272, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \
-	_(2273, ZEND_DECLARE_ANON_CLASS_SPEC) \
-	_(2274, ZEND_ADD_ARRAY_UNPACK_SPEC) \
-	_(2275, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
-	_(2276, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-	_(2277, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
-	_(2279, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV) \
-	_(2280, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-	_(2281, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2282, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2284, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-	_(2285, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) \
-	_(2286, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2287, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
-	_(2289, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
-	_(2290, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
-	_(2291, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2292, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
-	_(2294, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
-	_(2295, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
-	_(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-	_(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
-	_(2299, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
-	_(2300, ZEND_HANDLE_EXCEPTION_SPEC) \
-	_(2301, ZEND_USER_OPCODE_SPEC) \
-	_(2302, ZEND_ASSERT_CHECK_SPEC) \
-	_(2303, ZEND_JMP_SET_SPEC_CONST) \
-	_(2304, ZEND_JMP_SET_SPEC_TMP) \
-	_(2305, ZEND_JMP_SET_SPEC_VAR) \
-	_(2307, ZEND_JMP_SET_SPEC_CV) \
-	_(2308, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
-	_(2309, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
-	_(2310, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
-	_(2311, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
-	_(2312, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-	_(2313, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
-	_(2315, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
-	_(2316, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
-	_(2318, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
-	_(2319, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
-	_(2320, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
-	_(2321, ZEND_FETCH_CLASS_NAME_SPEC_CV) \
-	_(2322, ZEND_CALL_TRAMPOLINE_SPEC) \
-	_(2323, ZEND_DISCARD_EXCEPTION_SPEC) \
-	_(2324, ZEND_YIELD_SPEC_CONST_CONST) \
-	_(2325, ZEND_YIELD_SPEC_CONST_TMPVAR) \
-	_(2326, ZEND_YIELD_SPEC_CONST_TMPVAR) \
-	_(2327, ZEND_YIELD_SPEC_CONST_UNUSED) \
-	_(2328, ZEND_YIELD_SPEC_CONST_CV) \
-	_(2329, ZEND_YIELD_SPEC_TMP_CONST) \
-	_(2330, ZEND_YIELD_SPEC_TMP_TMPVAR) \
-	_(2331, ZEND_YIELD_SPEC_TMP_TMPVAR) \
-	_(2332, ZEND_YIELD_SPEC_TMP_UNUSED) \
-	_(2333, ZEND_YIELD_SPEC_TMP_CV) \
-	_(2334, ZEND_YIELD_SPEC_VAR_CONST) \
-	_(2335, ZEND_YIELD_SPEC_VAR_TMPVAR) \
-	_(2336, ZEND_YIELD_SPEC_VAR_TMPVAR) \
-	_(2337, ZEND_YIELD_SPEC_VAR_UNUSED) \
-	_(2338, ZEND_YIELD_SPEC_VAR_CV) \
-	_(2339, ZEND_YIELD_SPEC_UNUSED_CONST) \
-	_(2340, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
-	_(2341, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
-	_(2342, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
-	_(2343, ZEND_YIELD_SPEC_UNUSED_CV) \
-	_(2344, ZEND_YIELD_SPEC_CV_CONST) \
-	_(2345, ZEND_YIELD_SPEC_CV_TMPVAR) \
-	_(2346, ZEND_YIELD_SPEC_CV_TMPVAR) \
-	_(2347, ZEND_YIELD_SPEC_CV_UNUSED) \
-	_(2348, ZEND_YIELD_SPEC_CV_CV) \
-	_(2349, ZEND_GENERATOR_RETURN_SPEC_CONST) \
-	_(2350, ZEND_GENERATOR_RETURN_SPEC_TMP) \
-	_(2351, ZEND_GENERATOR_RETURN_SPEC_VAR) \
-	_(2353, ZEND_GENERATOR_RETURN_SPEC_CV) \
-	_(2354, ZEND_FAST_CALL_SPEC) \
-	_(2355, ZEND_FAST_RET_SPEC) \
-	_(2356, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
-	_(2357, ZEND_SEND_UNPACK_SPEC) \
-	_(2358, ZEND_YIELD_FROM_SPEC_CONST) \
-	_(2359, ZEND_YIELD_FROM_SPEC_TMPVAR) \
-	_(2360, ZEND_YIELD_FROM_SPEC_TMPVAR) \
-	_(2362, ZEND_YIELD_FROM_SPEC_CV) \
-	_(2363, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
-	_(2364, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
-	_(2365, ZEND_COALESCE_SPEC_CONST) \
-	_(2366, ZEND_COALESCE_SPEC_TMP) \
-	_(2367, ZEND_COALESCE_SPEC_VAR) \
-	_(2369, ZEND_COALESCE_SPEC_CV) \
-	_(2370, ZEND_SPACESHIP_SPEC_CONST_CONST) \
-	_(2371, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-	_(2372, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
-	_(2374, ZEND_SPACESHIP_SPEC_CONST_CV) \
-	_(2375, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-	_(2376, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2377, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2379, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-	_(2380, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
-	_(2381, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2382, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
-	_(2384, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
-	_(2390, ZEND_SPACESHIP_SPEC_CV_CONST) \
-	_(2391, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-	_(2392, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
-	_(2394, ZEND_SPACESHIP_SPEC_CV_CV) \
-	_(2395, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2396, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
-	_(2399, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2401, ZEND_FETCH_STATIC_PROP_R_SPEC) \
-	_(2402, ZEND_FETCH_STATIC_PROP_W_SPEC) \
-	_(2403, ZEND_FETCH_STATIC_PROP_RW_SPEC) \
-	_(2404, ZEND_FETCH_STATIC_PROP_IS_SPEC) \
-	_(2405, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \
-	_(2406, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \
-	_(2407, ZEND_UNSET_STATIC_PROP_SPEC) \
-	_(2408, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \
-	_(2409, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
-	_(2411, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
-	_(2412, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
-	_(2414, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
-	_(2415, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
-	_(2416, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
-	_(2417, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \
-	_(2420, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \
-	_(2422, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
-	_(2423, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
-	_(2424, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-	_(2425, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-	_(2427, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
-	_(2428, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
-	_(2429, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-	_(2430, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-	_(2432, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
-	_(2433, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
-	_(2434, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
-	_(2435, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
-	_(2437, ZEND_IN_ARRAY_SPEC_CV_CONST) \
-	_(2438, ZEND_COUNT_SPEC_CONST_UNUSED) \
-	_(2439, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
-	_(2440, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
-	_(2442, ZEND_COUNT_SPEC_CV_UNUSED) \
-	_(2443, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
-	_(2444, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
-	_(2445, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
-	_(2446, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
-	_(2447, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
-	_(2448, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
-	_(2449, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
-	_(2450, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
-	_(2451, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
-	_(2453, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
-	_(2454, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
-	_(2455, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-	_(2456, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
-	_(2458, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
-	_(2459, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-	_(2460, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2461, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2463, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-	_(2464, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
-	_(2465, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2466, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
-	_(2468, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
-	_(2474, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
-	_(2475, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-	_(2476, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
-	_(2478, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
-	_(2479, ZEND_MATCH_SPEC_CONST_CONST) \
-	_(2480, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
-	_(2481, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
-	_(2483, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
-	_(2489, ZEND_CASE_STRICT_SPEC_TMP_CONST) \
-	_(2490, ZEND_CASE_STRICT_SPEC_TMP_TMP) \
-	_(2491, ZEND_CASE_STRICT_SPEC_TMP_VAR) \
-	_(2493, ZEND_CASE_STRICT_SPEC_TMP_CV) \
-	_(2494, ZEND_CASE_STRICT_SPEC_VAR_CONST) \
-	_(2495, ZEND_CASE_STRICT_SPEC_VAR_TMP) \
-	_(2496, ZEND_CASE_STRICT_SPEC_VAR_VAR) \
-	_(2498, ZEND_CASE_STRICT_SPEC_VAR_CV) \
-	_(2509, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \
-	_(2510, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
-	_(2511, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
-	_(2513, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
-	_(2514, ZEND_JMP_NULL_SPEC_CONST) \
-	_(2515, ZEND_JMP_NULL_SPEC_TMPVARCV) \
-	_(2516, ZEND_JMP_NULL_SPEC_TMPVARCV) \
-	_(2518, ZEND_JMP_NULL_SPEC_TMPVARCV) \
-	_(2519, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \
-	_(2520, ZEND_RECV_NOTYPE_SPEC) \
-	_(2521, ZEND_JMP_FORWARD_SPEC) \
-	_(2527, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2528, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2529, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2531, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2532, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2533, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2534, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2536, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2542, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2543, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2544, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2546, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2552, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2553, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2554, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2556, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2557, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2558, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2559, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2561, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2567, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2568, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2569, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2571, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2577, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2578, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2579, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2581, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2582, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2583, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2584, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2586, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2592, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2593, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2594, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2596, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2598, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2599, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2601, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2602, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2603, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2604, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2606, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2607, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2608, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2609, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2611, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2617, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2618, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2619, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2621, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2623, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2624, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2626, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2627, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2628, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2629, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2631, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2632, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2633, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2634, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2636, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2642, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2643, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2644, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2646, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2648, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2649, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2651, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2652, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2653, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2654, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2656, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2657, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2658, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2659, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2661, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2667, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2668, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2669, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2671, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2677, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2678, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2679, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2681, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2682, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2683, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2684, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2686, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2692, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2693, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2694, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2696, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2702, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2703, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2704, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2706, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2707, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2708, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2709, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2711, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2717, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2718, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2719, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2721, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2727, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2728, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2729, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2731, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2732, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2733, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2734, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2736, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2742, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2743, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2744, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2746, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2762, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2763, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2764, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2765, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2766, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2767, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2768, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2769, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2770, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2774, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2775, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2776, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2777, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2778, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2779, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2780, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2781, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2782, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2783, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2784, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2785, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2789, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2808, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2809, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
-	_(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2814, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2815, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2820, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2837, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2838, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2839, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2840, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2841, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2842, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2843, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2844, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2845, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2849, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2850, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2851, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2852, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2853, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2854, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2855, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2856, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2857, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2858, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2859, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2860, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2864, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2883, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2884, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
-	_(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2889, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2890, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2895, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2912, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2913, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2914, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2915, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2916, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2917, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2918, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2919, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2920, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2924, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2925, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2926, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2927, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2928, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2929, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2930, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2931, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2932, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2933, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2934, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2935, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2939, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2958, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2959, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
-	_(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2964, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2965, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2970, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2987, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2988, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2989, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2990, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2991, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2992, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2993, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2994, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2995, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2999, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3000, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3001, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3002, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3003, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3004, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3005, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3006, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3007, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3008, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3009, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3010, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3014, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3033, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3034, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
-	_(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3039, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3040, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3045, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3047, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3051, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3052, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3056, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3060, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3061, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3062, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3063, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3064, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3065, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3069, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3070, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3071, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3072, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3073, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3074, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3075, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3076, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3077, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3078, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3079, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3080, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3084, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3085, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3086, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3087, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3088, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3089, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3090, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3091, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3092, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3093, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3094, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3095, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3099, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3118, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3119, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_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) \
-	_(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3124, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3125, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3130, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3135, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3136, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3137, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3138, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3139, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3140, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3144, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3145, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3146, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3147, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3148, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3149, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3150, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3151, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3152, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3153, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3154, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3155, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3159, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3160, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3161, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3162, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3163, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3164, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3165, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3169, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3170, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3193, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_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) \
-	_(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3210, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3211, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3212, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3213, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3214, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3215, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3219, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3220, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3221, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3222, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3223, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3224, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3225, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3226, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3227, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3228, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3229, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3230, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3234, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3235, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3236, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3237, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3238, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3239, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3240, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3244, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3245, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3268, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
-	_(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3285, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3286, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3287, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3288, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3289, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3290, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3294, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3295, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3296, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3297, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3298, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3299, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3300, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3301, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3302, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3303, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3304, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3305, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3309, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3310, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3311, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3312, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3313, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3314, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3315, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3319, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3320, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3343, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
-	_(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3357, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3358, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3359, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3360, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3361, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3362, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3363, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3364, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3365, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3366, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3367, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3368, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3369, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
-	_(3370, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3371, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3373, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3374, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-	_(3375, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3376, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3378, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3379, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-	_(3380, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3381, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3383, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3385, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3386, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3388, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3389, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3390, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3391, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3393, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3394, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3395, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3396, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3398, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3404, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-	_(3405, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3406, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3408, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3411, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-	_(3413, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-	_(3416, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
-	_(3418, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
-	_(3419, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-	_(3420, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-	_(3421, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-	_(3422, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-	_(3422+1, ZEND_NULL)
+	_(1352, ZEND_DO_FCALL_SPEC_RETVAL_UNUSED_OBSERVER) \
+	_(1353, ZEND_DO_FCALL_SPEC_RETVAL_USED_OBSERVER) \
+	_(1354, ZEND_INIT_FCALL_SPEC_CONST) \
+	_(1355, ZEND_RETURN_SPEC_CONST) \
+	_(1356, ZEND_RETURN_SPEC_CONST_OBSERVER) \
+	_(1357, ZEND_RETURN_SPEC_TMP) \
+	_(1358, ZEND_RETURN_SPEC_TMP_OBSERVER) \
+	_(1359, ZEND_RETURN_SPEC_VAR) \
+	_(1360, ZEND_RETURN_SPEC_VAR_OBSERVER) \
+	_(1363, ZEND_RETURN_SPEC_CV) \
+	_(1364, ZEND_RETURN_SPEC_CV_OBSERVER) \
+	_(1365, ZEND_RECV_SPEC_UNUSED) \
+	_(1366, ZEND_RECV_INIT_SPEC_CONST) \
+	_(1367, ZEND_SEND_VAL_SPEC_CONST_CONST) \
+	_(1370, ZEND_SEND_VAL_SPEC_CONST_UNUSED) \
+	_(1372, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \
+	_(1375, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \
+	_(1377, ZEND_SEND_VAL_SPEC_TMPVAR_CONST) \
+	_(1380, ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) \
+	_(1412, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \
+	_(1413, ZEND_SEND_VAR_EX_SPEC_VAR_CONST) \
+	_(1418, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED) \
+	_(1419, ZEND_SEND_VAR_EX_SPEC_VAR_UNUSED_QUICK) \
+	_(1432, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \
+	_(1433, ZEND_SEND_VAR_EX_SPEC_CV_CONST) \
+	_(1438, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED) \
+	_(1439, ZEND_SEND_VAR_EX_SPEC_CV_UNUSED_QUICK) \
+	_(1452, ZEND_SEND_REF_SPEC_VAR_CONST) \
+	_(1455, ZEND_SEND_REF_SPEC_VAR_UNUSED) \
+	_(1462, ZEND_SEND_REF_SPEC_CV_CONST) \
+	_(1465, ZEND_SEND_REF_SPEC_CV_UNUSED) \
+	_(1467, ZEND_NEW_SPEC_CONST_UNUSED) \
+	_(1469, ZEND_NEW_SPEC_VAR_UNUSED) \
+	_(1470, ZEND_NEW_SPEC_UNUSED_UNUSED) \
+	_(1472, ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST) \
+	_(1473, ZEND_FREE_SPEC_TMPVAR) \
+	_(1474, ZEND_INIT_ARRAY_SPEC_CONST_CONST) \
+	_(1475, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
+	_(1476, ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) \
+	_(1477, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED) \
+	_(1478, ZEND_INIT_ARRAY_SPEC_CONST_CV) \
+	_(1479, ZEND_INIT_ARRAY_SPEC_TMP_CONST) \
+	_(1480, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
+	_(1481, ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) \
+	_(1482, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) \
+	_(1483, ZEND_INIT_ARRAY_SPEC_TMP_CV) \
+	_(1484, ZEND_INIT_ARRAY_SPEC_VAR_CONST) \
+	_(1485, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
+	_(1486, ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) \
+	_(1487, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED) \
+	_(1488, ZEND_INIT_ARRAY_SPEC_VAR_CV) \
+	_(1489, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST) \
+	_(1490, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
+	_(1491, ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) \
+	_(1492, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED) \
+	_(1493, ZEND_INIT_ARRAY_SPEC_UNUSED_CV) \
+	_(1494, ZEND_INIT_ARRAY_SPEC_CV_CONST) \
+	_(1495, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
+	_(1496, ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) \
+	_(1497, ZEND_INIT_ARRAY_SPEC_CV_UNUSED) \
+	_(1498, ZEND_INIT_ARRAY_SPEC_CV_CV) \
+	_(1499, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST) \
+	_(1500, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
+	_(1501, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) \
+	_(1502, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED) \
+	_(1503, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV) \
+	_(1504, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) \
+	_(1505, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
+	_(1506, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) \
+	_(1507, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED) \
+	_(1508, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) \
+	_(1509, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST) \
+	_(1510, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
+	_(1511, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) \
+	_(1512, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED) \
+	_(1513, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV) \
+	_(1519, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST) \
+	_(1520, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
+	_(1521, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) \
+	_(1522, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED) \
+	_(1523, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV) \
+	_(1524, ZEND_INCLUDE_OR_EVAL_SPEC_CONST) \
+	_(1525, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_OBSERVER) \
+	_(1526, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
+	_(1527, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \
+	_(1528, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) \
+	_(1529, ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_OBSERVER) \
+	_(1532, ZEND_INCLUDE_OR_EVAL_SPEC_CV) \
+	_(1533, ZEND_INCLUDE_OR_EVAL_SPEC_CV_OBSERVER) \
+	_(1534, ZEND_UNSET_VAR_SPEC_CONST_UNUSED) \
+	_(1535, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
+	_(1536, ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) \
+	_(1538, ZEND_UNSET_VAR_SPEC_CV_UNUSED) \
+	_(1549, ZEND_UNSET_DIM_SPEC_VAR_CONST) \
+	_(1550, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
+	_(1551, ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) \
+	_(1553, ZEND_UNSET_DIM_SPEC_VAR_CV) \
+	_(1559, ZEND_UNSET_DIM_SPEC_CV_CONST) \
+	_(1560, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
+	_(1561, ZEND_UNSET_DIM_SPEC_CV_TMPVAR) \
+	_(1563, ZEND_UNSET_DIM_SPEC_CV_CV) \
+	_(1574, ZEND_UNSET_OBJ_SPEC_VAR_CONST) \
+	_(1575, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
+	_(1576, ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) \
+	_(1578, ZEND_UNSET_OBJ_SPEC_VAR_CV) \
+	_(1579, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST) \
+	_(1580, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(1581, ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(1583, ZEND_UNSET_OBJ_SPEC_UNUSED_CV) \
+	_(1584, ZEND_UNSET_OBJ_SPEC_CV_CONST) \
+	_(1585, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
+	_(1586, ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) \
+	_(1588, ZEND_UNSET_OBJ_SPEC_CV_CV) \
+	_(1589, ZEND_FE_RESET_R_SPEC_CONST) \
+	_(1590, ZEND_FE_RESET_R_SPEC_TMP) \
+	_(1591, ZEND_FE_RESET_R_SPEC_VAR) \
+	_(1593, ZEND_FE_RESET_R_SPEC_CV) \
+	_(1594, ZEND_FE_FETCH_R_SPEC_VAR) \
+	_(1595, ZEND_EXIT_SPEC) \
+	_(1596, ZEND_FETCH_R_SPEC_CONST_UNUSED) \
+	_(1597, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
+	_(1598, ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) \
+	_(1600, ZEND_FETCH_R_SPEC_CV_UNUSED) \
+	_(1601, ZEND_FETCH_DIM_R_SPEC_CONST_CONST) \
+	_(1602, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
+	_(1603, ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) \
+	_(1605, ZEND_FETCH_DIM_R_SPEC_CONST_CV) \
+	_(1606, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
+	_(1607, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+	_(1608, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+	_(1610, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
+	_(1611, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) \
+	_(1612, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+	_(1613, ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) \
+	_(1615, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) \
+	_(1621, ZEND_FETCH_DIM_R_SPEC_CV_CONST) \
+	_(1622, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
+	_(1623, ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) \
+	_(1625, ZEND_FETCH_DIM_R_SPEC_CV_CV) \
+	_(1626, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST) \
+	_(1627, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
+	_(1628, ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) \
+	_(1630, ZEND_FETCH_OBJ_R_SPEC_CONST_CV) \
+	_(1631, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
+	_(1632, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+	_(1633, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+	_(1635, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
+	_(1636, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST) \
+	_(1637, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+	_(1638, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) \
+	_(1640, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV) \
+	_(1641, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST) \
+	_(1642, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
+	_(1643, ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) \
+	_(1645, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV) \
+	_(1646, ZEND_FETCH_OBJ_R_SPEC_CV_CONST) \
+	_(1647, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
+	_(1648, ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) \
+	_(1650, ZEND_FETCH_OBJ_R_SPEC_CV_CV) \
+	_(1651, ZEND_FETCH_W_SPEC_CONST_UNUSED) \
+	_(1652, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
+	_(1653, ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) \
+	_(1655, ZEND_FETCH_W_SPEC_CV_UNUSED) \
+	_(1666, ZEND_FETCH_DIM_W_SPEC_VAR_CONST) \
+	_(1667, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
+	_(1668, ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) \
+	_(1669, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED) \
+	_(1670, ZEND_FETCH_DIM_W_SPEC_VAR_CV) \
+	_(1676, ZEND_FETCH_DIM_W_SPEC_CV_CONST) \
+	_(1677, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
+	_(1678, ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) \
+	_(1679, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED) \
+	_(1680, ZEND_FETCH_DIM_W_SPEC_CV_CV) \
+	_(1691, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST) \
+	_(1692, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
+	_(1693, ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) \
+	_(1695, ZEND_FETCH_OBJ_W_SPEC_VAR_CV) \
+	_(1696, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST) \
+	_(1697, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
+	_(1698, ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) \
+	_(1700, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV) \
+	_(1701, ZEND_FETCH_OBJ_W_SPEC_CV_CONST) \
+	_(1702, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
+	_(1703, ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) \
+	_(1705, ZEND_FETCH_OBJ_W_SPEC_CV_CV) \
+	_(1706, ZEND_FETCH_RW_SPEC_CONST_UNUSED) \
+	_(1707, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
+	_(1708, ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) \
+	_(1710, ZEND_FETCH_RW_SPEC_CV_UNUSED) \
+	_(1721, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST) \
+	_(1722, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
+	_(1723, ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) \
+	_(1724, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED) \
+	_(1725, ZEND_FETCH_DIM_RW_SPEC_VAR_CV) \
+	_(1731, ZEND_FETCH_DIM_RW_SPEC_CV_CONST) \
+	_(1732, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
+	_(1733, ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) \
+	_(1734, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED) \
+	_(1735, ZEND_FETCH_DIM_RW_SPEC_CV_CV) \
+	_(1746, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST) \
+	_(1747, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
+	_(1748, ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) \
+	_(1750, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV) \
+	_(1751, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST) \
+	_(1752, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
+	_(1753, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) \
+	_(1755, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV) \
+	_(1756, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST) \
+	_(1757, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
+	_(1758, ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) \
+	_(1760, ZEND_FETCH_OBJ_RW_SPEC_CV_CV) \
+	_(1761, ZEND_FETCH_IS_SPEC_CONST_UNUSED) \
+	_(1762, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
+	_(1763, ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) \
+	_(1765, ZEND_FETCH_IS_SPEC_CV_UNUSED) \
+	_(1766, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST) \
+	_(1767, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
+	_(1768, ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) \
+	_(1770, ZEND_FETCH_DIM_IS_SPEC_CONST_CV) \
+	_(1771, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
+	_(1772, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1773, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1775, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
+	_(1776, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST) \
+	_(1777, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1778, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1780, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV) \
+	_(1786, ZEND_FETCH_DIM_IS_SPEC_CV_CONST) \
+	_(1787, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
+	_(1788, ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) \
+	_(1790, ZEND_FETCH_DIM_IS_SPEC_CV_CV) \
+	_(1791, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST) \
+	_(1792, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
+	_(1793, ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) \
+	_(1795, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV) \
+	_(1796, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
+	_(1797, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1798, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1800, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
+	_(1801, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) \
+	_(1802, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1803, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) \
+	_(1805, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) \
+	_(1806, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST) \
+	_(1807, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
+	_(1808, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) \
+	_(1810, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV) \
+	_(1811, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST) \
+	_(1812, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
+	_(1813, ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) \
+	_(1815, ZEND_FETCH_OBJ_IS_SPEC_CV_CV) \
+	_(1816, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED) \
+	_(1817, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+	_(1818, ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) \
+	_(1820, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED) \
+	_(1821, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST) \
+	_(1822, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
+	_(1823, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) \
+	_(1824, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED) \
+	_(1825, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV) \
+	_(1826, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) \
+	_(1827, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
+	_(1828, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) \
+	_(1829, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) \
+	_(1830, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) \
+	_(1831, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST) \
+	_(1832, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
+	_(1833, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) \
+	_(1834, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED) \
+	_(1835, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV) \
+	_(1841, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST) \
+	_(1842, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
+	_(1843, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) \
+	_(1844, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED) \
+	_(1845, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV) \
+	_(1846, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST) \
+	_(1847, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
+	_(1848, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) \
+	_(1850, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV) \
+	_(1851, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) \
+	_(1852, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
+	_(1853, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) \
+	_(1855, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) \
+	_(1856, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST) \
+	_(1857, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
+	_(1858, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) \
+	_(1860, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV) \
+	_(1861, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST) \
+	_(1862, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
+	_(1863, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) \
+	_(1865, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV) \
+	_(1866, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST) \
+	_(1867, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
+	_(1868, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) \
+	_(1870, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV) \
+	_(1871, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED) \
+	_(1872, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
+	_(1873, ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) \
+	_(1875, ZEND_FETCH_UNSET_SPEC_CV_UNUSED) \
+	_(1886, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST) \
+	_(1887, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
+	_(1888, ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) \
+	_(1890, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV) \
+	_(1896, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST) \
+	_(1897, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
+	_(1898, ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) \
+	_(1900, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV) \
+	_(1911, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST) \
+	_(1912, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
+	_(1913, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) \
+	_(1915, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV) \
+	_(1916, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST) \
+	_(1917, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
+	_(1918, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) \
+	_(1920, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV) \
+	_(1921, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST) \
+	_(1922, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
+	_(1923, ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) \
+	_(1925, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV) \
+	_(1926, ZEND_FETCH_LIST_R_SPEC_CONST_CONST) \
+	_(1927, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
+	_(1928, ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) \
+	_(1930, ZEND_FETCH_LIST_R_SPEC_CONST_CV) \
+	_(1931, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+	_(1932, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1933, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1935, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+	_(1936, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+	_(1937, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1938, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1940, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+	_(1946, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST) \
+	_(1947, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1948, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) \
+	_(1950, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) \
+	_(1951, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST) \
+	_(1952, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \
+	_(1953, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_CONST) \
+	_(1958, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED) \
+	_(1959, ZEND_CHECK_FUNC_ARG_SPEC_UNUSED_UNUSED_QUICK) \
+	_(1962, ZEND_EXT_STMT_SPEC) \
+	_(1963, ZEND_EXT_FCALL_BEGIN_SPEC) \
+	_(1964, ZEND_EXT_FCALL_END_SPEC) \
+	_(1965, ZEND_EXT_NOP_SPEC) \
+	_(1966, ZEND_TICKS_SPEC) \
+	_(1967, ZEND_SEND_VAR_NO_REF_SPEC_VAR_CONST) \
+	_(1970, ZEND_SEND_VAR_NO_REF_SPEC_VAR_UNUSED) \
+	_(1972, ZEND_CATCH_SPEC_CONST) \
+	_(1973, ZEND_THROW_SPEC_CONST) \
+	_(1974, ZEND_THROW_SPEC_TMPVAR) \
+	_(1975, ZEND_THROW_SPEC_TMPVAR) \
+	_(1977, ZEND_THROW_SPEC_CV) \
+	_(1978, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST) \
+	_(1979, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
+	_(1980, ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) \
+	_(1981, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) \
+	_(1982, ZEND_FETCH_CLASS_SPEC_UNUSED_CV) \
+	_(1983, ZEND_CLONE_SPEC_CONST) \
+	_(1984, ZEND_CLONE_SPEC_TMPVAR) \
+	_(1985, ZEND_CLONE_SPEC_TMPVAR) \
+	_(1986, ZEND_CLONE_SPEC_UNUSED) \
+	_(1987, ZEND_CLONE_SPEC_CV) \
+	_(1988, ZEND_RETURN_BY_REF_SPEC_CONST) \
+	_(1989, ZEND_RETURN_BY_REF_SPEC_CONST_OBSERVER) \
+	_(1990, ZEND_RETURN_BY_REF_SPEC_TMP) \
+	_(1991, ZEND_RETURN_BY_REF_SPEC_TMP_OBSERVER) \
+	_(1992, ZEND_RETURN_BY_REF_SPEC_VAR) \
+	_(1993, ZEND_RETURN_BY_REF_SPEC_VAR_OBSERVER) \
+	_(1996, ZEND_RETURN_BY_REF_SPEC_CV) \
+	_(1997, ZEND_RETURN_BY_REF_SPEC_CV_OBSERVER) \
+	_(1998, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST) \
+	_(1999, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
+	_(2000, ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) \
+	_(2002, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV) \
+	_(2003, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
+	_(2004, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+	_(2005, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+	_(2007, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
+	_(2008, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) \
+	_(2009, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+	_(2010, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) \
+	_(2012, ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) \
+	_(2013, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST) \
+	_(2014, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+	_(2015, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+	_(2017, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV) \
+	_(2018, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST) \
+	_(2019, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
+	_(2020, ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) \
+	_(2022, ZEND_INIT_METHOD_CALL_SPEC_CV_CV) \
+	_(2023, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST) \
+	_(2024, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
+	_(2025, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) \
+	_(2026, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED) \
+	_(2027, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV) \
+	_(2033, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST) \
+	_(2034, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
+	_(2035, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) \
+	_(2036, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED) \
+	_(2037, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV) \
+	_(2038, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST) \
+	_(2039, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+	_(2040, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) \
+	_(2041, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED) \
+	_(2042, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV) \
+	_(2048, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED) \
+	_(2049, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
+	_(2050, ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) \
+	_(2052, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED) \
+	_(2053, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST) \
+	_(2054, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
+	_(2055, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) \
+	_(2057, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV) \
+	_(2058, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
+	_(2059, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2060, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2062, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
+	_(2063, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) \
+	_(2064, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2065, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2067, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) \
+	_(2073, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST) \
+	_(2074, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
+	_(2075, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) \
+	_(2077, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV) \
+	_(2078, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \
+	_(2079, ZEND_SEND_VAL_EX_SPEC_CONST_CONST) \
+	_(2084, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED) \
+	_(2085, ZEND_SEND_VAL_EX_SPEC_CONST_UNUSED_QUICK) \
+	_(2088, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \
+	_(2089, ZEND_SEND_VAL_EX_SPEC_TMP_CONST) \
+	_(2094, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED) \
+	_(2095, ZEND_SEND_VAL_EX_SPEC_TMP_UNUSED_QUICK) \
+	_(2138, ZEND_SEND_VAR_SPEC_VAR_CONST) \
+	_(2141, ZEND_SEND_VAR_SPEC_VAR_UNUSED) \
+	_(2148, ZEND_SEND_VAR_SPEC_CV_CONST) \
+	_(2151, ZEND_SEND_VAR_SPEC_CV_UNUSED) \
+	_(2153, ZEND_INIT_USER_CALL_SPEC_CONST_CONST) \
+	_(2154, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
+	_(2155, ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) \
+	_(2157, ZEND_INIT_USER_CALL_SPEC_CONST_CV) \
+	_(2158, ZEND_SEND_ARRAY_SPEC) \
+	_(2159, ZEND_SEND_USER_SPEC_CONST) \
+	_(2160, ZEND_SEND_USER_SPEC_TMP) \
+	_(2161, ZEND_SEND_USER_SPEC_VAR) \
+	_(2163, ZEND_SEND_USER_SPEC_CV) \
+	_(2164, ZEND_STRLEN_SPEC_CONST) \
+	_(2165, ZEND_STRLEN_SPEC_TMPVAR) \
+	_(2166, ZEND_STRLEN_SPEC_TMPVAR) \
+	_(2168, ZEND_STRLEN_SPEC_CV) \
+	_(2169, ZEND_DEFINED_SPEC_CONST) \
+	_(2170, ZEND_TYPE_CHECK_SPEC_CONST) \
+	_(2171, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
+	_(2172, ZEND_TYPE_CHECK_SPEC_TMPVAR) \
+	_(2174, ZEND_TYPE_CHECK_SPEC_CV) \
+	_(2175, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED) \
+	_(2176, ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UNUSED) \
+	_(2177, ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UNUSED) \
+	_(2178, ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED_UNUSED) \
+	_(2179, ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNUSED) \
+	_(2180, ZEND_FE_RESET_RW_SPEC_CONST) \
+	_(2181, ZEND_FE_RESET_RW_SPEC_TMP) \
+	_(2182, ZEND_FE_RESET_RW_SPEC_VAR) \
+	_(2184, ZEND_FE_RESET_RW_SPEC_CV) \
+	_(2185, ZEND_FE_FETCH_RW_SPEC_VAR) \
+	_(2186, ZEND_FE_FREE_SPEC_TMPVAR) \
+	_(2187, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST) \
+	_(2188, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
+	_(2189, ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) \
+	_(2191, ZEND_INIT_DYNAMIC_CALL_SPEC_CV) \
+	_(2192, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED) \
+	_(2193, ZEND_DO_ICALL_SPEC_RETVAL_USED) \
+	_(2194, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED) \
+	_(2195, ZEND_DO_UCALL_SPEC_RETVAL_USED) \
+	_(2196, ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_OBSERVER) \
+	_(2197, ZEND_DO_UCALL_SPEC_RETVAL_USED_OBSERVER) \
+	_(2198, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED) \
+	_(2199, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED) \
+	_(2200, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_UNUSED_OBSERVER) \
+	_(2201, ZEND_DO_FCALL_BY_NAME_SPEC_RETVAL_USED_OBSERVER) \
+	_(2212, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST) \
+	_(2213, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2214, ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2216, ZEND_PRE_INC_OBJ_SPEC_VAR_CV) \
+	_(2217, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST) \
+	_(2218, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2219, ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2221, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV) \
+	_(2222, ZEND_PRE_INC_OBJ_SPEC_CV_CONST) \
+	_(2223, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2224, ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2226, ZEND_PRE_INC_OBJ_SPEC_CV_CV) \
+	_(2237, ZEND_POST_INC_OBJ_SPEC_VAR_CONST) \
+	_(2238, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2239, ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) \
+	_(2241, ZEND_POST_INC_OBJ_SPEC_VAR_CV) \
+	_(2242, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST) \
+	_(2243, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2244, ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2246, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV) \
+	_(2247, ZEND_POST_INC_OBJ_SPEC_CV_CONST) \
+	_(2248, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2249, ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) \
+	_(2251, ZEND_POST_INC_OBJ_SPEC_CV_CV) \
+	_(2252, ZEND_ECHO_SPEC_CONST) \
+	_(2253, ZEND_ECHO_SPEC_TMPVAR) \
+	_(2254, ZEND_ECHO_SPEC_TMPVAR) \
+	_(2256, ZEND_ECHO_SPEC_CV) \
+	_(2263, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+	_(2265, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+	_(2266, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+	_(2268, ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) \
+	_(2270, ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) \
+	_(2271, ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) \
+	_(2278, ZEND_INSTANCEOF_SPEC_CV_CONST) \
+	_(2280, ZEND_INSTANCEOF_SPEC_CV_VAR) \
+	_(2281, ZEND_INSTANCEOF_SPEC_CV_UNUSED) \
+	_(2283, ZEND_GENERATOR_CREATE_SPEC) \
+	_(2286, ZEND_MAKE_REF_SPEC_VAR_UNUSED) \
+	_(2288, ZEND_MAKE_REF_SPEC_CV_UNUSED) \
+	_(2289, ZEND_DECLARE_FUNCTION_SPEC) \
+	_(2290, ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED) \
+	_(2291, ZEND_DECLARE_CONST_SPEC_CONST_CONST) \
+	_(2292, ZEND_DECLARE_CLASS_SPEC_CONST) \
+	_(2293, ZEND_DECLARE_CLASS_DELAYED_SPEC_CONST_CONST) \
+	_(2294, ZEND_DECLARE_ANON_CLASS_SPEC) \
+	_(2295, ZEND_ADD_ARRAY_UNPACK_SPEC) \
+	_(2296, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST) \
+	_(2297, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+	_(2298, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) \
+	_(2300, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_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_TMPVAR_CONST) \
+	_(2307, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2308, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) \
+	_(2310, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) \
+	_(2311, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST) \
+	_(2312, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2313, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) \
+	_(2315, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV) \
+	_(2316, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST) \
+	_(2317, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+	_(2318, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) \
+	_(2320, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV) \
+	_(2321, ZEND_HANDLE_EXCEPTION_SPEC) \
+	_(2322, ZEND_HANDLE_EXCEPTION_SPEC_OBSERVER) \
+	_(2323, ZEND_USER_OPCODE_SPEC) \
+	_(2324, ZEND_ASSERT_CHECK_SPEC) \
+	_(2325, ZEND_JMP_SET_SPEC_CONST) \
+	_(2326, ZEND_JMP_SET_SPEC_TMP) \
+	_(2327, ZEND_JMP_SET_SPEC_VAR) \
+	_(2329, ZEND_JMP_SET_SPEC_CV) \
+	_(2330, ZEND_UNSET_CV_SPEC_CV_UNUSED) \
+	_(2331, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET) \
+	_(2332, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY) \
+	_(2333, ZEND_FETCH_LIST_W_SPEC_VAR_CONST) \
+	_(2334, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+	_(2335, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
+	_(2337, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
+	_(2338, ZEND_SEPARATE_SPEC_VAR_UNUSED) \
+	_(2340, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
+	_(2341, ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) \
+	_(2342, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED) \
+	_(2343, ZEND_FETCH_CLASS_NAME_SPEC_CV) \
+	_(2344, ZEND_CALL_TRAMPOLINE_SPEC) \
+	_(2345, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER) \
+	_(2346, ZEND_DISCARD_EXCEPTION_SPEC) \
+	_(2347, ZEND_YIELD_SPEC_CONST_CONST) \
+	_(2348, ZEND_YIELD_SPEC_CONST_TMPVAR) \
+	_(2349, ZEND_YIELD_SPEC_CONST_TMPVAR) \
+	_(2350, ZEND_YIELD_SPEC_CONST_UNUSED) \
+	_(2351, ZEND_YIELD_SPEC_CONST_CV) \
+	_(2352, ZEND_YIELD_SPEC_TMP_CONST) \
+	_(2353, ZEND_YIELD_SPEC_TMP_TMPVAR) \
+	_(2354, ZEND_YIELD_SPEC_TMP_TMPVAR) \
+	_(2355, ZEND_YIELD_SPEC_TMP_UNUSED) \
+	_(2356, ZEND_YIELD_SPEC_TMP_CV) \
+	_(2357, ZEND_YIELD_SPEC_VAR_CONST) \
+	_(2358, ZEND_YIELD_SPEC_VAR_TMPVAR) \
+	_(2359, ZEND_YIELD_SPEC_VAR_TMPVAR) \
+	_(2360, ZEND_YIELD_SPEC_VAR_UNUSED) \
+	_(2361, ZEND_YIELD_SPEC_VAR_CV) \
+	_(2362, ZEND_YIELD_SPEC_UNUSED_CONST) \
+	_(2363, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
+	_(2364, ZEND_YIELD_SPEC_UNUSED_TMPVAR) \
+	_(2365, ZEND_YIELD_SPEC_UNUSED_UNUSED) \
+	_(2366, ZEND_YIELD_SPEC_UNUSED_CV) \
+	_(2367, ZEND_YIELD_SPEC_CV_CONST) \
+	_(2368, ZEND_YIELD_SPEC_CV_TMPVAR) \
+	_(2369, ZEND_YIELD_SPEC_CV_TMPVAR) \
+	_(2370, ZEND_YIELD_SPEC_CV_UNUSED) \
+	_(2371, ZEND_YIELD_SPEC_CV_CV) \
+	_(2372, ZEND_GENERATOR_RETURN_SPEC_CONST) \
+	_(2373, ZEND_GENERATOR_RETURN_SPEC_CONST_OBSERVER) \
+	_(2374, ZEND_GENERATOR_RETURN_SPEC_TMP) \
+	_(2375, ZEND_GENERATOR_RETURN_SPEC_TMP_OBSERVER) \
+	_(2376, ZEND_GENERATOR_RETURN_SPEC_VAR) \
+	_(2377, ZEND_GENERATOR_RETURN_SPEC_VAR_OBSERVER) \
+	_(2380, ZEND_GENERATOR_RETURN_SPEC_CV) \
+	_(2381, ZEND_GENERATOR_RETURN_SPEC_CV_OBSERVER) \
+	_(2382, ZEND_FAST_CALL_SPEC) \
+	_(2383, ZEND_FAST_RET_SPEC) \
+	_(2384, ZEND_RECV_VARIADIC_SPEC_UNUSED) \
+	_(2385, ZEND_SEND_UNPACK_SPEC) \
+	_(2386, ZEND_YIELD_FROM_SPEC_CONST) \
+	_(2387, ZEND_YIELD_FROM_SPEC_TMPVAR) \
+	_(2388, ZEND_YIELD_FROM_SPEC_TMPVAR) \
+	_(2390, ZEND_YIELD_FROM_SPEC_CV) \
+	_(2391, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) \
+	_(2392, ZEND_BIND_GLOBAL_SPEC_CV_CONST) \
+	_(2393, ZEND_COALESCE_SPEC_CONST) \
+	_(2394, ZEND_COALESCE_SPEC_TMP) \
+	_(2395, ZEND_COALESCE_SPEC_VAR) \
+	_(2397, ZEND_COALESCE_SPEC_CV) \
+	_(2398, ZEND_SPACESHIP_SPEC_CONST_CONST) \
+	_(2399, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+	_(2400, ZEND_SPACESHIP_SPEC_CONST_TMPVAR) \
+	_(2402, ZEND_SPACESHIP_SPEC_CONST_CV) \
+	_(2403, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+	_(2404, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2405, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2407, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+	_(2408, ZEND_SPACESHIP_SPEC_TMPVAR_CONST) \
+	_(2409, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2410, ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) \
+	_(2412, ZEND_SPACESHIP_SPEC_TMPVAR_CV) \
+	_(2418, ZEND_SPACESHIP_SPEC_CV_CONST) \
+	_(2419, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+	_(2420, ZEND_SPACESHIP_SPEC_CV_TMPVAR) \
+	_(2422, ZEND_SPACESHIP_SPEC_CV_CV) \
+	_(2423, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2424, ZEND_FUNC_GET_ARGS_SPEC_CONST_UNUSED) \
+	_(2427, ZEND_FUNC_GET_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2429, ZEND_FETCH_STATIC_PROP_R_SPEC) \
+	_(2430, ZEND_FETCH_STATIC_PROP_W_SPEC) \
+	_(2431, ZEND_FETCH_STATIC_PROP_RW_SPEC) \
+	_(2432, ZEND_FETCH_STATIC_PROP_IS_SPEC) \
+	_(2433, ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC) \
+	_(2434, ZEND_FETCH_STATIC_PROP_UNSET_SPEC) \
+	_(2435, ZEND_UNSET_STATIC_PROP_SPEC) \
+	_(2436, ZEND_ISSET_ISEMPTY_STATIC_PROP_SPEC) \
+	_(2437, ZEND_FETCH_CLASS_CONSTANT_SPEC_CONST_CONST) \
+	_(2439, ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_CONST) \
+	_(2440, ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_CONST) \
+	_(2442, ZEND_BIND_LEXICAL_SPEC_TMP_CV) \
+	_(2443, ZEND_BIND_STATIC_SPEC_CV_UNUSED) \
+	_(2444, ZEND_FETCH_THIS_SPEC_UNUSED_UNUSED) \
+	_(2445, ZEND_SEND_FUNC_ARG_SPEC_VAR_CONST) \
+	_(2448, ZEND_SEND_FUNC_ARG_SPEC_VAR_UNUSED) \
+	_(2450, ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED_UNUSED) \
+	_(2451, ZEND_SWITCH_LONG_SPEC_CONST_CONST) \
+	_(2452, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+	_(2453, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+	_(2455, ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONST) \
+	_(2456, ZEND_SWITCH_STRING_SPEC_CONST_CONST) \
+	_(2457, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+	_(2458, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+	_(2460, ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST) \
+	_(2461, ZEND_IN_ARRAY_SPEC_CONST_CONST) \
+	_(2462, ZEND_IN_ARRAY_SPEC_TMP_CONST) \
+	_(2463, ZEND_IN_ARRAY_SPEC_VAR_CONST) \
+	_(2465, ZEND_IN_ARRAY_SPEC_CV_CONST) \
+	_(2466, ZEND_COUNT_SPEC_CONST_UNUSED) \
+	_(2467, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
+	_(2468, ZEND_COUNT_SPEC_TMPVAR_UNUSED) \
+	_(2470, ZEND_COUNT_SPEC_CV_UNUSED) \
+	_(2471, ZEND_GET_CLASS_SPEC_CONST_UNUSED) \
+	_(2472, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
+	_(2473, ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) \
+	_(2474, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED) \
+	_(2475, ZEND_GET_CLASS_SPEC_CV_UNUSED) \
+	_(2476, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED) \
+	_(2477, ZEND_GET_TYPE_SPEC_CONST_UNUSED) \
+	_(2478, ZEND_GET_TYPE_SPEC_TMP_UNUSED) \
+	_(2479, ZEND_GET_TYPE_SPEC_VAR_UNUSED) \
+	_(2481, ZEND_GET_TYPE_SPEC_CV_UNUSED) \
+	_(2482, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
+	_(2483, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+	_(2484, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+	_(2486, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
+	_(2487, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+	_(2488, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2489, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2491, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+	_(2492, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+	_(2493, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2494, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+	_(2496, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+	_(2502, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
+	_(2503, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+	_(2504, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+	_(2506, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
+	_(2507, ZEND_MATCH_SPEC_CONST_CONST) \
+	_(2508, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
+	_(2509, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
+	_(2511, ZEND_MATCH_SPEC_TMPVARCV_CONST) \
+	_(2517, ZEND_CASE_STRICT_SPEC_TMP_CONST) \
+	_(2518, ZEND_CASE_STRICT_SPEC_TMP_TMP) \
+	_(2519, ZEND_CASE_STRICT_SPEC_TMP_VAR) \
+	_(2521, ZEND_CASE_STRICT_SPEC_TMP_CV) \
+	_(2522, ZEND_CASE_STRICT_SPEC_VAR_CONST) \
+	_(2523, ZEND_CASE_STRICT_SPEC_VAR_TMP) \
+	_(2524, ZEND_CASE_STRICT_SPEC_VAR_VAR) \
+	_(2526, ZEND_CASE_STRICT_SPEC_VAR_CV) \
+	_(2537, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED) \
+	_(2538, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
+	_(2539, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
+	_(2541, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) \
+	_(2542, ZEND_JMP_NULL_SPEC_CONST) \
+	_(2543, ZEND_JMP_NULL_SPEC_TMPVARCV) \
+	_(2544, ZEND_JMP_NULL_SPEC_TMPVARCV) \
+	_(2546, ZEND_JMP_NULL_SPEC_TMPVARCV) \
+	_(2547, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED) \
+	_(2548, ZEND_RECV_NOTYPE_SPEC) \
+	_(2549, ZEND_JMP_FORWARD_SPEC) \
+	_(2555, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2556, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2557, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2559, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2560, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2561, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2562, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2564, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2570, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2571, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2572, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2574, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2580, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2581, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2582, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2584, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2585, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2586, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2587, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2589, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2595, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2596, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2597, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2599, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2605, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2606, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2607, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2609, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2610, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2611, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2612, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2614, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2620, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2621, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2622, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2624, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2626, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2627, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2629, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2630, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2631, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2632, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2634, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2635, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2636, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2637, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2639, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2645, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2646, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2647, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2649, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2651, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2652, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2654, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2655, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2656, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2657, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2659, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2660, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2661, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2662, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2664, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2670, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2671, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2672, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2674, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2676, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2677, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2679, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2680, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2681, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2682, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2684, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2685, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2686, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2687, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2689, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2695, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2696, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2697, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2699, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2705, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2706, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2707, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2709, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2710, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2711, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2712, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2714, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2720, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2721, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2722, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2724, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2730, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2731, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2732, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2734, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2735, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2736, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2737, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2739, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2745, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2746, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2747, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2749, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2755, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2756, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2757, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2759, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2760, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2761, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2762, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2764, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2770, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2771, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2772, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2774, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2790, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2791, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2792, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(2796, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2797, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2798, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2802, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2803, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2804, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2805, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2806, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2807, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(2811, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2812, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2813, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2817, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2818, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2819, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2865, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2866, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2867, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(2871, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2872, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2873, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2877, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2878, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2879, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2880, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2881, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2882, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(2886, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2887, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2888, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2892, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2893, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2894, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2940, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2941, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2942, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(2946, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2947, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2948, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2952, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2953, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2954, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2955, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2956, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2957, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(2961, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2962, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2963, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2967, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2968, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2969, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3015, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3016, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3017, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3021, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3022, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3023, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3027, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3028, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3029, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3030, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3031, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3032, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3036, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3037, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3038, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3042, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3043, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3044, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3075, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3079, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3080, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3084, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(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) \
+	_(3091, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3092, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3093, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3097, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3098, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3099, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3100, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3101, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3102, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3106, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3107, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3108, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3112, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3113, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3114, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3115, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3116, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3117, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3121, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3122, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3123, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3127, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3128, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3129, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_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) \
+	_(3166, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3167, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3168, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3172, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3173, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3174, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3175, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3176, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3177, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3181, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3182, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3183, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3187, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3188, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3189, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3190, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3191, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3192, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_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) \
+	_(3241, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3242, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3243, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3247, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3248, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3249, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3250, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3251, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3252, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3256, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3257, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3258, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3262, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3263, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3264, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3265, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3266, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3267, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_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) \
+	_(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_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) \
+	_(3316, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3317, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3318, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3322, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3323, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3324, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3325, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3326, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3327, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3331, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3332, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3333, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3337, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3338, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3339, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3340, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3341, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3342, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_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) \
+	_(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3385, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3386, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3387, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3388, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3389, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3390, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3391, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3392, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3393, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3394, ZEND_POST_INC_LONG_SPEC_CV) \
+	_(3395, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3396, ZEND_POST_DEC_LONG_SPEC_CV) \
+	_(3397, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
+	_(3398, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3399, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3401, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3402, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+	_(3403, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3404, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3406, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3407, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+	_(3408, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3409, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3411, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3413, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3414, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3416, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3417, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3418, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3419, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3421, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3422, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3423, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3424, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3426, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3432, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+	_(3433, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3434, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3436, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3439, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+	_(3441, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+	_(3444, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
+	_(3446, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
+	_(3447, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+	_(3448, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+	_(3449, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+	_(3450, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+	_(3450+1, ZEND_NULL)
diff --git a/configure.ac b/configure.ac
index 116bb6031f..7e7f3edec4 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1458,7 +1458,8 @@ PHP_ADD_SOURCES(Zend, \
     zend_iterators.c zend_interfaces.c zend_exceptions.c zend_strtod.c zend_gc.c \
     zend_closures.c zend_weakrefs.c zend_float.c zend_string.c zend_signal.c zend_generators.c \
     zend_virtual_cwd.c zend_ast.c zend_objects.c zend_object_handlers.c zend_objects_API.c \
-    zend_default_classes.c zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_gdb.c, \
+    zend_default_classes.c zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_gdb.c \
+    zend_observer.c, \
 	-DZEND_ENABLE_STATIC_TSRMLS_CACHE=1)
 
 PHP_ADD_BUILD_DIR(main main/streams)
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index 9ee1a5b5d7..725b33d913 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -44,6 +44,7 @@
 #include "zend_accelerator_util_funcs.h"
 #include "zend_accelerator_hash.h"
 #include "zend_file_cache.h"
+#include "zend_observer.h"
 #include "ext/pcre/php_pcre.h"
 #include "ext/standard/md5.h"
 #include "ext/hash/php_hash.h"
@@ -2977,6 +2978,15 @@ static zend_result accel_post_startup(void)
 		}
 	}
 
+#ifdef HAVE_JIT
+	/* TODO Observer support for JIT */
+	if (ZEND_OBSERVER_ENABLED) {
+		JIT_G(enabled) = 0;
+		JIT_G(on) = 0;
+		zend_accel_error(ACCEL_LOG_INFO, "Observer extension present. Disabling JIT.");
+	}
+#endif
+
 	/* Initialize zend_func_info_rid */
 	zend_optimizer_startup();
 
diff --git a/ext/zend_test/test.c b/ext/zend_test/test.c
index 900c70f59d..64fd421292 100644
--- a/ext/zend_test/test.c
+++ b/ext/zend_test/test.c
@@ -21,9 +21,27 @@
 #include "php.h"
 #include "php_ini.h"
 #include "ext/standard/info.h"
+#include "ext/standard/php_var.h"
 #include "php_test.h"
 #include "test_arginfo.h"
 #include "zend_attributes.h"
+#include "zend_observer.h"
+#include "zend_smart_str.h"
+
+ZEND_BEGIN_MODULE_GLOBALS(zend_test)
+	int observer_enabled;
+	int observer_show_output;
+	int observer_observe_all;
+	int observer_observe_includes;
+	int observer_observe_functions;
+	int observer_show_return_type;
+	int observer_show_return_value;
+	int observer_nesting_depth;
+ZEND_END_MODULE_GLOBALS(zend_test)
+
+ZEND_DECLARE_MODULE_GLOBALS(zend_test)
+
+#define ZT_G(v) ZEND_MODULE_GLOBALS_ACCESSOR(zend_test, v)
 
 static zend_class_entry *zend_test_interface;
 static zend_class_entry *zend_test_class;
@@ -277,6 +295,18 @@ ZEND_METHOD(_ZendTestTrait, testMethod) /* {{{ */ {
 }
 /* }}} */
 
+PHP_INI_BEGIN()
+	STD_PHP_INI_BOOLEAN("zend_test.observer.enabled", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_enabled, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.show_output", "1", PHP_INI_SYSTEM, OnUpdateBool, observer_show_output, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.observe_all", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_all, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.observe_includes", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_includes, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.observe_functions", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_observe_functions, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.show_return_type", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_show_return_type, zend_zend_test_globals, zend_test_globals)
+	STD_PHP_INI_BOOLEAN("zend_test.observer.show_return_value", "0", PHP_INI_SYSTEM, OnUpdateBool, observer_show_return_value, zend_zend_test_globals, zend_test_globals)
+PHP_INI_END()
+
+static zend_observer_fcall observer_fcall_init(zend_function *fbc);
+
 PHP_MINIT_FUNCTION(zend_test)
 {
 	zend_class_entry class_entry;
@@ -362,19 +392,118 @@ PHP_MINIT_FUNCTION(zend_test)
 		attr->validator = zend_attribute_validate_zendtestattribute;
 	}
 
+	// Loading via dl() not supported with the observer API
+	if (type != MODULE_TEMPORARY) {
+		REGISTER_INI_ENTRIES();
+		if (ZT_G(observer_enabled)) {
+			zend_observer_fcall_register(observer_fcall_init);
+		}
+	} else {
+		(void)ini_entries;
+	}
+
 	return SUCCESS;
 }
 
 PHP_MSHUTDOWN_FUNCTION(zend_test)
 {
+	if (type != MODULE_TEMPORARY) {
+		UNREGISTER_INI_ENTRIES();
+	}
+
 	return SUCCESS;
 }
 
+static void observer_begin(zend_execute_data *execute_data)
+{
+	if (!ZT_G(observer_show_output)) {
+		return;
+	}
+
+	if (execute_data->func && execute_data->func->common.function_name) {
+		if (execute_data->func->common.scope) {
+			php_printf("%*s<%s::%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name));
+		} else {
+			php_printf("%*s<%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name));
+		}
+	} else {
+		php_printf("%*s<file '%s'>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->op_array.filename));
+	}
+	ZT_G(observer_nesting_depth)++;
+}
+
+static void get_retval_info(zval *retval, smart_str *buf)
+{
+	if (!ZT_G(observer_show_return_type) && !ZT_G(observer_show_return_value)) {
+		return;
+	}
+
+	smart_str_appendc(buf, ':');
+	if (retval == NULL) {
+		smart_str_appendl(buf, "NULL", 4);
+	} else if (ZT_G(observer_show_return_value)) {
+		php_var_export_ex(retval, 2 * ZT_G(observer_nesting_depth) + 3, buf);
+	} else if (ZT_G(observer_show_return_type)) {
+		smart_str_appends(buf, zend_zval_type_name(retval));
+	}
+	smart_str_0(buf);
+}
+
+static void observer_end(zend_execute_data *execute_data, zval *retval)
+{
+	if (!ZT_G(observer_show_output)) {
+		return;
+	}
+
+	if (EG(exception)) {
+		php_printf("%*s<!-- Exception: %s -->\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(EG(exception)->ce->name));
+	}
+	ZT_G(observer_nesting_depth)--;
+	if (execute_data->func && execute_data->func->common.function_name) {
+		smart_str retval_info = {0};
+		get_retval_info(retval, &retval_info);
+		if (execute_data->func->common.scope) {
+			php_printf("%*s</%s::%s%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.scope->name), ZSTR_VAL(execute_data->func->common.function_name), retval_info.s ? ZSTR_VAL(retval_info.s) : "");
+		} else {
+			php_printf("%*s</%s%s>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->common.function_name), retval_info.s ? ZSTR_VAL(retval_info.s) : "");
+		}
+		smart_str_free(&retval_info);
+	} else {
+		php_printf("%*s</file '%s'>\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(execute_data->func->op_array.filename));
+	}
+}
+
+static void observer_show_init(zend_function *fbc)
+{
+	if (fbc->common.function_name) {
+		if (fbc->common.scope) {
+			php_printf("%*s<!-- init %s::%s() -->\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.scope->name), ZSTR_VAL(fbc->common.function_name));
+		} else {
+			php_printf("%*s<!-- init %s() -->\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->common.function_name));
+		}
+	} else {
+		php_printf("%*s<!-- init '%s' -->\n", 2 * ZT_G(observer_nesting_depth), "", ZSTR_VAL(fbc->op_array.filename));
+	}
+}
+
+static zend_observer_fcall observer_fcall_init(zend_function *fbc)
+{
+	if (ZT_G(observer_show_output)) {
+		observer_show_init(fbc);
+	}
+
+	if (ZT_G(observer_observe_all)) {
+		return (zend_observer_fcall){observer_begin, observer_end};
+	} else if (ZT_G(observer_observe_includes) && !fbc->common.function_name) {
+		return (zend_observer_fcall){observer_begin, observer_end};
+	} else if (ZT_G(observer_observe_functions) && fbc->common.function_name) {
+		return (zend_observer_fcall){observer_begin, observer_end};
+	}
+	return (zend_observer_fcall){NULL, NULL};
+}
+
 PHP_RINIT_FUNCTION(zend_test)
 {
-#if defined(COMPILE_DL_ZEND_TEST) && defined(ZTS)
-	ZEND_TSRMLS_CACHE_UPDATE();
-#endif
 	return SUCCESS;
 }
 
@@ -383,11 +512,21 @@ PHP_RSHUTDOWN_FUNCTION(zend_test)
 	return SUCCESS;
 }
 
+static PHP_GINIT_FUNCTION(zend_test)
+{
+#if defined(COMPILE_DL_ZEND_TEST) && defined(ZTS)
+	ZEND_TSRMLS_CACHE_UPDATE();
+#endif
+	memset(zend_test_globals, 0, sizeof(*zend_test_globals));
+}
+
 PHP_MINFO_FUNCTION(zend_test)
 {
 	php_info_print_table_start();
 	php_info_print_table_header(2, "zend-test extension", "enabled");
 	php_info_print_table_end();
+
+	DISPLAY_INI_ENTRIES();
 }
 
 zend_module_entry zend_test_module_entry = {
@@ -400,7 +539,11 @@ zend_module_entry zend_test_module_entry = {
 	PHP_RSHUTDOWN(zend_test),
 	PHP_MINFO(zend_test),
 	PHP_ZEND_TEST_VERSION,
-	STANDARD_MODULE_PROPERTIES
+	PHP_MODULE_GLOBALS(zend_test),
+	PHP_GINIT(zend_test),
+	NULL,
+	NULL,
+	STANDARD_MODULE_PROPERTIES_EX
 };
 
 #ifdef COMPILE_DL_ZEND_TEST
diff --git a/ext/zend_test/tests/observer.inc b/ext/zend_test/tests/observer.inc
new file mode 100644
index 0000000000..611e9fa0e6
--- /dev/null
+++ b/ext/zend_test/tests/observer.inc
@@ -0,0 +1,8 @@
+<?php
+
+function foo_observer_test()
+{
+    echo __FUNCTION__ . PHP_EOL;
+}
+
+foo_observer_test();
diff --git a/ext/zend_test/tests/observer_basic_01.phpt b/ext/zend_test/tests/observer_basic_01.phpt
new file mode 100644
index 0000000000..9e31204dbe
--- /dev/null
+++ b/ext/zend_test/tests/observer_basic_01.phpt
@@ -0,0 +1,55 @@
+--TEST--
+Observer: Basic observability of userland functions
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+function bar()
+{
+    echo 'Bar' . PHP_EOL;
+    var_dump(array_sum([1,2,3]));
+}
+
+function foo()
+{
+    echo 'Foo' . PHP_EOL;
+    bar();
+}
+
+foo();
+foo();
+foo();
+
+echo 'DONE' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_basic_01.php' -->
+<file '%s/observer_basic_01.php'>
+  <!-- init foo() -->
+  <foo>
+Foo
+    <!-- init bar() -->
+    <bar>
+Bar
+int(6)
+    </bar>
+  </foo>
+  <foo>
+Foo
+    <bar>
+Bar
+int(6)
+    </bar>
+  </foo>
+  <foo>
+Foo
+    <bar>
+Bar
+int(6)
+    </bar>
+  </foo>
+DONE
+</file '%s/observer_basic_01.php'>
diff --git a/ext/zend_test/tests/observer_basic_02.phpt b/ext/zend_test/tests/observer_basic_02.phpt
new file mode 100644
index 0000000000..9d16b4fe18
--- /dev/null
+++ b/ext/zend_test/tests/observer_basic_02.phpt
@@ -0,0 +1,59 @@
+--TEST--
+Observer: Basic observability of userland methods
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+class TestClass
+{
+    private function bar()
+    {
+        echo 'Bar' . PHP_EOL;
+        var_dump(array_sum([1,2,3]));
+    }
+
+    public function foo()
+    {
+        echo 'Foo' . PHP_EOL;
+        $this->bar();
+    }
+}
+
+$test = new TestClass();
+$test->foo();
+$test->foo();
+$test->foo();
+
+echo 'DONE' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_basic_02.php' -->
+<file '%s/observer_basic_02.php'>
+  <!-- init TestClass::foo() -->
+  <TestClass::foo>
+Foo
+    <!-- init TestClass::bar() -->
+    <TestClass::bar>
+Bar
+int(6)
+    </TestClass::bar>
+  </TestClass::foo>
+  <TestClass::foo>
+Foo
+    <TestClass::bar>
+Bar
+int(6)
+    </TestClass::bar>
+  </TestClass::foo>
+  <TestClass::foo>
+Foo
+    <TestClass::bar>
+Bar
+int(6)
+    </TestClass::bar>
+  </TestClass::foo>
+DONE
+</file '%s/observer_basic_02.php'>
diff --git a/ext/zend_test/tests/observer_basic_03.phpt b/ext/zend_test/tests/observer_basic_03.phpt
new file mode 100644
index 0000000000..6a2d0b16ee
--- /dev/null
+++ b/ext/zend_test/tests/observer_basic_03.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Observer: Basic observability of includes
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+function foo()
+{
+    echo 'Foo' . PHP_EOL;
+}
+
+foo();
+include __DIR__ . '/observer.inc';
+foo();
+?>
+--EXPECTF--
+<!-- init '%s/observer_basic_03.php' -->
+<file '%s/observer_basic_03.php'>
+  <!-- init foo() -->
+  <foo>
+Foo
+  </foo>
+  <!-- init '%s/observer.inc' -->
+  <file '%s/observer.inc'>
+    <!-- init foo_observer_test() -->
+    <foo_observer_test>
+foo_observer_test
+    </foo_observer_test>
+  </file '%s/observer.inc'>
+  <foo>
+Foo
+  </foo>
+</file '%s/observer_basic_03.php'>
diff --git a/ext/zend_test/tests/observer_basic_04.phpt b/ext/zend_test/tests/observer_basic_04.phpt
new file mode 100644
index 0000000000..6c0a8df59d
--- /dev/null
+++ b/ext/zend_test/tests/observer_basic_04.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Observer: Basic observability of includes only (no functions)
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_includes=1
+--FILE--
+<?php
+function foo()
+{
+    echo 'Foo' . PHP_EOL;
+}
+
+foo();
+include __DIR__ . '/observer.inc';
+foo();
+?>
+--EXPECTF--
+<!-- init '%s/observer_basic_04.php' -->
+<file '%s/observer_basic_04.php'>
+  <!-- init foo() -->
+Foo
+  <!-- init '%s/observer.inc' -->
+  <file '%s/observer.inc'>
+    <!-- init foo_observer_test() -->
+foo_observer_test
+  </file '%s/observer.inc'>
+Foo
+</file '%s/observer_basic_04.php'>
diff --git a/ext/zend_test/tests/observer_basic_05.phpt b/ext/zend_test/tests/observer_basic_05.phpt
new file mode 100644
index 0000000000..27462aadb3
--- /dev/null
+++ b/ext/zend_test/tests/observer_basic_05.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Observer: Basic observability of functions only (no includes)
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_functions=1
+--FILE--
+<?php
+function foo()
+{
+    echo 'Foo' . PHP_EOL;
+}
+
+foo();
+include __DIR__ . '/observer.inc';
+foo();
+?>
+--EXPECTF--
+<!-- init '%s/observer_basic_05.php' -->
+<!-- init foo() -->
+<foo>
+Foo
+</foo>
+<!-- init '%s/observer.inc' -->
+<!-- init foo_observer_test() -->
+<foo_observer_test>
+foo_observer_test
+</foo_observer_test>
+<foo>
+Foo
+</foo>
diff --git a/ext/zend_test/tests/observer_closure_01.phpt b/ext/zend_test/tests/observer_closure_01.phpt
new file mode 100644
index 0000000000..3e120493bc
--- /dev/null
+++ b/ext/zend_test/tests/observer_closure_01.phpt
@@ -0,0 +1,49 @@
+--TEST--
+Observer: Basic observability of closures
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+$bar = function() {
+    var_dump(array_sum([40,2]));
+};
+
+$foo = function($bar) {
+    echo 'Answer' . PHP_EOL;
+    $bar();
+};
+
+$foo($bar);
+$foo($bar);
+$foo($bar);
+
+echo 'DONE' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_closure_%d.php' -->
+<file '%s/observer_closure_%d.php'>
+  <!-- init {closure}() -->
+  <{closure}>
+Answer
+    <!-- init {closure}() -->
+    <{closure}>
+int(42)
+    </{closure}>
+  </{closure}>
+  <{closure}>
+Answer
+    <{closure}>
+int(42)
+    </{closure}>
+  </{closure}>
+  <{closure}>
+Answer
+    <{closure}>
+int(42)
+    </{closure}>
+  </{closure}>
+DONE
+</file '%s/observer_closure_%d.php'>
diff --git a/ext/zend_test/tests/observer_eval_01.phpt b/ext/zend_test/tests/observer_eval_01.phpt
new file mode 100644
index 0000000000..1a230c7d96
--- /dev/null
+++ b/ext/zend_test/tests/observer_eval_01.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Observer: Basic eval observability
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+echo eval("return 'Foo eval' . PHP_EOL;");
+echo 'DONE' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_eval_%d.php' -->
+<file '%s/observer_eval_%d.php'>
+  <!-- init '%s/observer_eval_%d.php(%d) : eval()'d code' -->
+  <file '%s/observer_eval_%d.php(%d) : eval()'d code'>
+  </file '%s/observer_eval_%d.php(%d) : eval()'d code'>
+Foo eval
+DONE
+</file '%s/observer_eval_%d.php'>
diff --git a/ext/zend_test/tests/observer_exception_01.phpt b/ext/zend_test/tests/observer_exception_01.phpt
new file mode 100644
index 0000000000..fd49c0618b
--- /dev/null
+++ b/ext/zend_test/tests/observer_exception_01.phpt
@@ -0,0 +1,46 @@
+--TEST--
+Observer: Basic observability of userland functions with uncaught exceptions
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+function foo()
+{
+    static $callCount = 0;
+    echo 'Call #' . $callCount . PHP_EOL;
+    if (++$callCount == 3) {
+        throw new RuntimeException('Third time is a charm');
+    }
+}
+
+foo();
+foo();
+foo();
+
+echo 'You should not see this' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_exception_%d.php' -->
+<file '%s/observer_exception_%d.php'>
+  <!-- init foo() -->
+  <foo>
+Call #0
+  </foo>
+  <foo>
+Call #1
+  </foo>
+  <foo>
+Call #2
+    <!-- Exception: RuntimeException -->
+  </foo>
+  <!-- Exception: RuntimeException -->
+</file '%s/observer_exception_%d.php'>
+
+Fatal error: Uncaught RuntimeException: Third time is a charm in %s/observer_exception_%d.php:%d
+Stack trace:
+#0 %s/observer_exception_%d.php(%d): foo()
+#1 {main}
+  thrown in %s/observer_exception_%d.php on line %d
diff --git a/ext/zend_test/tests/observer_generator_01.phpt b/ext/zend_test/tests/observer_generator_01.phpt
new file mode 100644
index 0000000000..a2d8b02a2b
--- /dev/null
+++ b/ext/zend_test/tests/observer_generator_01.phpt
@@ -0,0 +1,47 @@
+--TEST--
+Observer: Basic generator observability
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+zend_test.observer.show_return_value=1
+--FILE--
+<?php
+function getResults() {
+    for ($i = 10; $i < 13; $i++) {
+        yield $i;
+    }
+}
+
+function doSomething() {
+    $generator = getResults();
+    foreach ($generator as $value) {
+        echo $value . PHP_EOL;
+    }
+
+    return 'Done';
+}
+
+echo doSomething() . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_generator_%d.php' -->
+<file '%s/observer_generator_%d.php'>
+  <!-- init doSomething() -->
+  <doSomething>
+    <!-- init getResults() -->
+    <getResults>
+    </getResults:10>
+10
+    <getResults>
+    </getResults:11>
+11
+    <getResults>
+    </getResults:12>
+12
+    <getResults>
+    </getResults:NULL>
+  </doSomething:'Done'>
+Done
+</file '%s/observer_generator_%d.php'>
diff --git a/ext/zend_test/tests/observer_generator_02.phpt b/ext/zend_test/tests/observer_generator_02.phpt
new file mode 100644
index 0000000000..2e045f93f2
--- /dev/null
+++ b/ext/zend_test/tests/observer_generator_02.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Observer: Generator with explicit return
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+zend_test.observer.show_return_value=1
+--FILE--
+<?php
+function getResults() {
+    for ($i = 10; $i < 13; $i++) {
+        yield $i;
+    }
+    return 1337;
+}
+
+function doSomething() {
+    $generator = getResults();
+    foreach ($generator as $value) {
+        echo $value . PHP_EOL;
+    }
+    echo $generator->getReturn() . PHP_EOL;
+
+    return 'Done';
+}
+
+echo doSomething() . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_generator_%d.php' -->
+<file '%s/observer_generator_%d.php'>
+  <!-- init doSomething() -->
+  <doSomething>
+    <!-- init getResults() -->
+    <getResults>
+    </getResults:10>
+10
+    <getResults>
+    </getResults:11>
+11
+    <getResults>
+    </getResults:12>
+12
+    <getResults>
+    </getResults:1337>
+1337
+  </doSomething:'Done'>
+Done
+</file '%s/observer_generator_%d.php'>
diff --git a/ext/zend_test/tests/observer_generator_03.phpt b/ext/zend_test/tests/observer_generator_03.phpt
new file mode 100644
index 0000000000..459bdfb424
--- /dev/null
+++ b/ext/zend_test/tests/observer_generator_03.phpt
@@ -0,0 +1,68 @@
+--TEST--
+Observer: Generator with 'yield from'
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+zend_test.observer.show_return_value=1
+--FILE--
+<?php
+function barResults() {
+    for ($i = 10; $i < 13; $i++) {
+        yield $i;
+    }
+}
+
+function fooResults() {
+    yield 0;
+    yield 1;
+    yield from barResults();
+    yield 42;
+}
+
+function doSomething() {
+    $generator = fooResults();
+    foreach ($generator as $value) {
+        echo $value . PHP_EOL;
+    }
+
+    return 'Done';
+}
+
+echo doSomething() . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_generator_%d.php' -->
+<file '%s/observer_generator_%d.php'>
+  <!-- init doSomething() -->
+  <doSomething>
+    <!-- init fooResults() -->
+    <fooResults>
+    </fooResults:0>
+0
+    <fooResults>
+    </fooResults:1>
+1
+    <fooResults>
+    </fooResults:1>
+    <!-- init barResults() -->
+    <barResults>
+    </barResults:10>
+10
+    <barResults>
+    </barResults:11>
+11
+    <barResults>
+    </barResults:12>
+12
+    <barResults>
+    </barResults:NULL>
+    <fooResults>
+    </fooResults:42>
+42
+    <fooResults>
+    </fooResults:NULL>
+  </doSomething:'Done'>
+Done
+</file '%s/observer_generator_%d.php'>
diff --git a/ext/zend_test/tests/observer_generator_04.phpt b/ext/zend_test/tests/observer_generator_04.phpt
new file mode 100644
index 0000000000..6c2f182077
--- /dev/null
+++ b/ext/zend_test/tests/observer_generator_04.phpt
@@ -0,0 +1,64 @@
+--TEST--
+Observer: Generator with manual traversal
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+zend_test.observer.show_return_value=1
+--FILE--
+<?php
+function fooResults() {
+    echo 'Starting generator' . PHP_EOL;
+    $i = 0;
+    while (true) {
+        if (yield $i++) break;
+    }
+}
+
+function doSomething() {
+    $generator = fooResults();
+    
+    while($generator->current() !== NULL) {
+        echo $generator->current() . PHP_EOL;
+        if ($generator->current() === 5) {
+            $generator->send('Boop');
+        }
+        $generator->next();
+    }
+
+    return 'Done';
+}
+
+echo doSomething() . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_generator_%d.php' -->
+<file '%s/observer_generator_%d.php'>
+  <!-- init doSomething() -->
+  <doSomething>
+    <!-- init fooResults() -->
+    <fooResults>
+Starting generator
+    </fooResults:0>
+0
+    <fooResults>
+    </fooResults:1>
+1
+    <fooResults>
+    </fooResults:2>
+2
+    <fooResults>
+    </fooResults:3>
+3
+    <fooResults>
+    </fooResults:4>
+4
+    <fooResults>
+    </fooResults:5>
+5
+    <fooResults>
+    </fooResults:NULL>
+  </doSomething:'Done'>
+Done
+</file '%s/observer_generator_%d.php'>
diff --git a/ext/zend_test/tests/observer_jit_01.phpt b/ext/zend_test/tests/observer_jit_01.phpt
new file mode 100644
index 0000000000..f489986b6e
--- /dev/null
+++ b/ext/zend_test/tests/observer_jit_01.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Observer: JIT is disabled when observer extension is present
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+<?php if (!extension_loaded('Zend OPcache')) die('skip: OPcache extension required'); ?>
+<?php if (!isset(opcache_get_status()['jit'])) die('skip: Build with JIT required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+opcache.enable=1
+opcache.enable_cli=1
+opcache.jit=1
+opcache.jit_buffer_size=1M
+--FILE--
+<?php
+$status = opcache_get_status();
+echo 'JIT enabled: ' . ($status['jit']['enabled'] ? 'yes' : 'no') . PHP_EOL;
+echo 'JIT on: ' . ($status['jit']['on'] ? 'yes' : 'no') . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_jit_%d.php' -->
+<file '%s/observer_jit_%d.php'>
+JIT enabled: no
+JIT on: no
+</file '%s/observer_jit_%d.php'>
diff --git a/ext/zend_test/tests/observer_magic_01.phpt b/ext/zend_test/tests/observer_magic_01.phpt
new file mode 100644
index 0000000000..920f934b6c
--- /dev/null
+++ b/ext/zend_test/tests/observer_magic_01.phpt
@@ -0,0 +1,45 @@
+--TEST--
+Observer: Basic magic method observability
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+class MagicTest
+{
+    public function __call($name, $args)
+    {
+        echo '__call()' . PHP_EOL;
+        $this->foo($name);
+    }
+
+    public function foo($name)
+    {
+        echo $name . PHP_EOL;
+    }
+}
+
+$test = new MagicTest();
+$test->foo('test');
+$test->bar();
+
+echo 'DONE' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_magic_01.php' -->
+<file '%s/observer_magic_01.php'>
+  <!-- init MagicTest::foo() -->
+  <MagicTest::foo>
+test
+  </MagicTest::foo>
+  <!-- init MagicTest::__call() -->
+  <MagicTest::__call>
+__call()
+    <MagicTest::foo>
+bar
+    </MagicTest::foo>
+  </MagicTest::__call>
+DONE
+</file '%s/observer_magic_01.php'>
diff --git a/ext/zend_test/tests/observer_zend_call_function_01.phpt b/ext/zend_test/tests/observer_zend_call_function_01.phpt
new file mode 100644
index 0000000000..03d7287470
--- /dev/null
+++ b/ext/zend_test/tests/observer_zend_call_function_01.phpt
@@ -0,0 +1,36 @@
+--TEST--
+Observer: Calls that go through zend_call_function are observed
+--SKIPIF--
+<?php if (!extension_loaded('zend-test')) die('skip: zend-test extension required'); ?>
+--INI--
+zend_test.observer.enabled=1
+zend_test.observer.observe_all=1
+--FILE--
+<?php
+function sum($carry, $item) {
+    $carry += $item;
+    return $carry;
+}
+
+$a = [1, 2, 3, 4, 5];
+// array_reduce() calls zend_call_function() under the hood
+var_dump(array_reduce($a, 'sum'));
+echo 'Done' . PHP_EOL;
+?>
+--EXPECTF--
+<!-- init '%s/observer_zend_call_function_%d.php' -->
+<file '%s/observer_zend_call_function_%d.php'>
+  <!-- init sum() -->
+  <sum>
+  </sum>
+  <sum>
+  </sum>
+  <sum>
+  </sum>
+  <sum>
+  </sum>
+  <sum>
+  </sum>
+int(15)
+Done
+</file '%s/observer_zend_call_function_%d.php'>
diff --git a/main/main.c b/main/main.c
index 9a92447f41..9eb610fe64 100644
--- a/main/main.c
+++ b/main/main.c
@@ -71,6 +71,7 @@
 #include "zend_extensions.h"
 #include "zend_ini.h"
 #include "zend_dtrace.h"
+#include "zend_observer.h"
 
 #include "php_content_types.h"
 #include "php_ticks.h"
@@ -2199,6 +2200,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
 	php_startup_auto_globals();
 	zend_set_utility_values(&zuv);
 	php_startup_sapi_content_types();
+	zend_observer_startup();
 
 	/* startup extensions statically compiled in */
 	if (php_register_internal_extensions_func() == FAILURE) {
@@ -2416,6 +2418,8 @@ void php_module_shutdown(void)
 		_set_invalid_parameter_handler(old_invalid_parameter_handler);
 	}
 #endif
+
+	zend_observer_shutdown();
 }
 /* }}} */
 
diff --git a/win32/build/config.w32 b/win32/build/config.w32
index 9b5e44c37d..94e4cbe1c5 100644
--- a/win32/build/config.w32
+++ b/win32/build/config.w32
@@ -237,7 +237,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
 	zend_object_handlers.c zend_objects_API.c \
 	zend_default_classes.c zend_execute.c zend_strtod.c zend_gc.c zend_closures.c zend_weakrefs.c \
 	zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \
-	zend_inheritance.c zend_smart_str.c zend_cpuinfo.c");
+	zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c");
 
 ADD_FLAG("CFLAGS_BD_ZEND", "/D ZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
 if (VS_TOOLSET && VCVERS >= 1914) {