diff --git a/Zend/tests/errmsg/errmsg_027.phpt b/Zend/tests/errmsg/errmsg_027.phpt
index 3d96ec27b4d64..a30e1269453f9 100644
--- a/Zend/tests/errmsg/errmsg_027.phpt
+++ b/Zend/tests/errmsg/errmsg_027.phpt
@@ -13,4 +13,4 @@ class test {
 echo "Done\n";
 ?>
 --EXPECTF--
-Fatal error: Class declarations may not be nested in %s on line %d
+Fatal error: Class declarations may not be declared inside functions in %s on line %d
diff --git a/Zend/zend.h b/Zend/zend.h
index 0cf1faeb653fe..912008d43d997 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -164,6 +164,10 @@ struct _zend_class_entry {
 	HashTable properties_info;
 	HashTable constants_table;
 
+	zend_class_entry *required_scope;
+	zend_class_entry *lexical_scope;
+	char required_scope_absolute;
+
 	ZEND_MAP_PTR_DEF(zend_class_mutable_data*, mutable_data);
 	zend_inheritance_cache_entry *inheritance_cache;
 
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index d0dad8490c4e3..2bf4638f0348e 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -133,6 +133,7 @@ enum _zend_ast_kind {
 	ZEND_AST_YIELD,
 	ZEND_AST_COALESCE,
 	ZEND_AST_ASSIGN_COALESCE,
+	ZEND_AST_INNER_CLASS,
 
 	ZEND_AST_STATIC,
 	ZEND_AST_WHILE,
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index e5df485919942..1c6e61294296c 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -893,12 +893,12 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token
 			}
 			break;
 		case T_READONLY:
-			if (target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_CPP) {
+			if (target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_CPP || target == ZEND_MODIFIER_TARGET_INNER_CLASS) {
 				return ZEND_ACC_READONLY;
 			}
 			break;
 		case T_ABSTRACT:
-			if (target == ZEND_MODIFIER_TARGET_METHOD || target == ZEND_MODIFIER_TARGET_PROPERTY) {
+			if (target == ZEND_MODIFIER_TARGET_METHOD || target == ZEND_MODIFIER_TARGET_PROPERTY || target == ZEND_MODIFIER_TARGET_INNER_CLASS) {
 				return ZEND_ACC_ABSTRACT;
 			}
 			break;
@@ -906,6 +906,7 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token
 			if (target == ZEND_MODIFIER_TARGET_METHOD
 				|| target == ZEND_MODIFIER_TARGET_CONSTANT
 				|| target == ZEND_MODIFIER_TARGET_PROPERTY
+				|| target == ZEND_MODIFIER_TARGET_INNER_CLASS
 				|| target == ZEND_MODIFIER_TARGET_PROPERTY_HOOK) {
 				return ZEND_ACC_FINAL;
 			}
@@ -943,6 +944,8 @@ uint32_t zend_modifier_token_to_flag(zend_modifier_target target, uint32_t token
 		member = "parameter";
 	} else if (target == ZEND_MODIFIER_TARGET_PROPERTY_HOOK) {
 		member = "property hook";
+	} else if (target == ZEND_MODIFIER_TARGET_INNER_CLASS) {
+		member = "inner class";
 	} else {
 		ZEND_UNREACHABLE();
 	}
@@ -1050,6 +1053,37 @@ uint32_t zend_add_member_modifier(uint32_t flags, uint32_t new_flag, zend_modifi
 			return 0;
 		}
 	}
+	if (target == ZEND_MODIFIER_TARGET_INNER_CLASS) {
+		if ((flags & ZEND_ACC_PPP_MASK) && (new_flag & ZEND_ACC_PPP_MASK)) {
+			zend_throw_exception(zend_ce_compile_error,
+				"Multiple access type modifiers are not allowed", 0);
+			return 0;
+		}
+
+		if ((flags & ZEND_ACC_STATIC) || (new_flag & ZEND_ACC_STATIC)) {
+			zend_throw_exception(zend_ce_compile_error,
+				"Static inner classes are not allowed", 0);
+			return 0;
+		}
+
+		if ((flags & ZEND_ACC_PUBLIC_SET) || (new_flag & ZEND_ACC_PUBLIC_SET)) {
+			zend_throw_exception(zend_ce_compile_error,
+				"Public(set) inner classes are not allowed", 0);
+			return 0;
+		}
+
+		if ((flags & ZEND_ACC_PROTECTED_SET) || (new_flag & ZEND_ACC_PROTECTED_SET)) {
+			zend_throw_exception(zend_ce_compile_error,
+				"Protected(set) inner classes are not allowed", 0);
+			return 0;
+		}
+
+		if ((flags & ZEND_ACC_PRIVATE_SET) || (new_flag & ZEND_ACC_PRIVATE_SET)) {
+			zend_throw_exception(zend_ce_compile_error,
+				"Private(set) inner classes are not allowed", 0);
+			return 0;
+		}
+	}
 	return new_flags;
 }
 /* }}} */
@@ -1760,8 +1794,45 @@ static uint32_t zend_get_class_fetch_type_ast(zend_ast *name_ast) /* {{{ */
 }
 /* }}} */
 
+static bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *class_ast);
+
+static zend_string *zend_resolve_nested_class_name(zend_ast *ast) /* {{{ */
+{
+	ZEND_ASSERT(ast->kind == ZEND_AST_INNER_CLASS);
+
+	zend_ast *outer_class = ast->child[0];
+	zend_ast *inner_class = ast->child[1];
+
+	zend_string *outer_name, *inner_name, *full_name;
+
+	if (outer_class->kind == ZEND_AST_INNER_CLASS) {
+		outer_name = zend_resolve_nested_class_name(outer_class);
+	} else {
+		zval outer_class_name;
+		zend_try_compile_const_expr_resolve_class_name(&outer_class_name, outer_class);
+		outer_name = Z_STR(outer_class_name);
+	}
+
+	inner_name = zend_ast_get_str(inner_class);
+
+	full_name = zend_string_concat3(
+		ZSTR_VAL(outer_name), ZSTR_LEN(outer_name),
+		":>", 2,
+		ZSTR_VAL(inner_name), ZSTR_LEN(inner_name)
+	);
+
+	zend_string_release(outer_name);
+
+	return full_name;
+}
+/* }}} */
+
 static zend_string *zend_resolve_const_class_name_reference(zend_ast *ast, const char *type)
 {
+	if (ast->kind == ZEND_AST_INNER_CLASS) {
+		return zend_resolve_nested_class_name(ast);
+	}
+
 	zend_string *class_name = zend_ast_get_str(ast);
 	if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type_ast(ast)) {
 		zend_error_noreturn(E_COMPILE_ERROR,
@@ -1792,6 +1863,11 @@ static bool zend_try_compile_const_expr_resolve_class_name(zval *zv, zend_ast *c
 	uint32_t fetch_type;
 	zval *class_name;
 
+	if (class_ast->kind == ZEND_AST_INNER_CLASS) {
+		ZVAL_STR(zv, zend_resolve_nested_class_name(class_ast));
+		return 1;
+	}
+
 	if (class_ast->kind != ZEND_AST_ZVAL) {
 		return 0;
 	}
@@ -2844,10 +2920,42 @@ static inline void zend_set_class_name_op1(zend_op *opline, znode *class_node) /
 }
 /* }}} */
 
+static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t fetch_flags);
+
+static void zend_compile_inner_class_ref(znode *result, zend_ast *ast, uint32_t fetch_flags) /* {{{ */
+{
+	zend_ast *outer_class = ast->child[0];
+	zend_ast *inner_class = ast->child[1];
+
+	znode outer_node, inner_node;
+
+	// handle nesting
+	if (outer_class->kind == ZEND_AST_INNER_CLASS) {
+		zend_compile_inner_class_ref(&outer_node, outer_class, fetch_flags);
+	} else {
+		zend_compile_class_ref(&outer_node, outer_class, fetch_flags | ZEND_FETCH_CLASS_OUTER);
+	}
+
+	if (inner_class->kind == ZEND_AST_ZVAL && Z_TYPE_P(zend_ast_get_zval(inner_class)) == IS_STRING) {
+		ZVAL_STR(&inner_node.u.constant, zend_string_dup(Z_STR_P(zend_ast_get_zval(inner_class)), 0));
+		inner_node.op_type = IS_CONST;
+	} else {
+		zend_compile_expr(&inner_node, inner_class);
+	}
+
+	zend_emit_op(result, ZEND_FETCH_INNER_CLASS, &outer_node, &inner_node);
+}
+/* }}} */
+
 static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t fetch_flags) /* {{{ */
 {
 	uint32_t fetch_type;
 
+	if (name_ast->kind == ZEND_AST_INNER_CLASS) {
+		zend_compile_inner_class_ref(result, name_ast, fetch_flags);
+		return;
+	}
+
 	if (name_ast->kind != ZEND_AST_ZVAL) {
 		znode name_node;
 
@@ -2891,10 +2999,12 @@ static void zend_compile_class_ref(znode *result, zend_ast *name_ast, uint32_t f
 	if (ZEND_FETCH_CLASS_DEFAULT == fetch_type) {
 		result->op_type = IS_CONST;
 		ZVAL_STR(&result->u.constant, zend_resolve_class_name_ast(name_ast));
+	} else if (fetch_flags & ZEND_FETCH_CLASS_OUTER && fetch_type == ZEND_FETCH_CLASS_STATIC) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use the static modifier on an inner class");
 	} else {
 		zend_ensure_valid_class_fetch_type(fetch_type);
 		result->op_type = IS_UNUSED;
-		result->u.op.num = fetch_type | fetch_flags;
+		result->u.op.num = fetch_type | (fetch_flags & ~ZEND_FETCH_CLASS_OUTER);
 	}
 }
 /* }}} */
@@ -7316,6 +7426,9 @@ static zend_type zend_compile_typename_ex(
 			ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_INTERSECTION_BIT;
 			ZEND_TYPE_FULL_MASK(type) |= _ZEND_TYPE_ARENA_BIT;
 		}
+	} else if (ast->kind == ZEND_AST_INNER_CLASS) {
+		zend_string *name = zend_resolve_nested_class_name(ast);
+		return (zend_type) ZEND_TYPE_INIT_CLASS(name, /* allow null */ false, 0);
 	} else {
 		type = zend_compile_single_typename(ast);
 	}
@@ -9057,10 +9170,6 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 	if (EXPECTED((decl->flags & ZEND_ACC_ANON_CLASS) == 0)) {
 		zend_string *unqualified_name = decl->name;
 
-		if (CG(active_class_entry)) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
-		}
-
 		const char *type = "a class name";
 		if (decl->flags & ZEND_ACC_ENUM) {
 			type = "an enum name";
@@ -9070,7 +9179,51 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 			type = "a trait name";
 		}
 		zend_assert_valid_class_name(unqualified_name, type);
-		name = zend_prefix_with_ns(unqualified_name);
+
+		if (CG(active_class_entry) && CG(active_op_array)->function_name) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be declared inside functions");
+		}
+
+		if (CG(active_class_entry)) {
+			// rename the inner class so we may reference it by name
+			name = zend_string_concat3(
+				ZSTR_VAL(CG(active_class_entry)->name), ZSTR_LEN(CG(active_class_entry)->name),
+				":>", 2,
+				ZSTR_VAL(unqualified_name), ZSTR_LEN(unqualified_name)
+			);
+
+			// configure the current ce->flags for a nested class. This should only include:
+			// - final
+			// - readonly
+			// - abstract
+			decl->flags |= decl->attr & ZEND_ACC_FINAL;
+			if (decl->attr & ZEND_ACC_ABSTRACT) {
+				decl->flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
+			}
+			if (decl->attr & ZEND_ACC_READONLY) {
+				decl->flags |= ZEND_ACC_READONLY_CLASS | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+			}
+
+			// configure for a nested class. This should only include:
+			// - public
+			// - private
+			// - protected
+			int propFlags = decl->attr & (ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE);
+			// remove the flags from attrs
+			decl->attr &= ~(ZEND_ACC_PUBLIC|ZEND_ACC_PROTECTED|ZEND_ACC_PRIVATE|ZEND_ACC_FINAL|ZEND_ACC_ABSTRACT|ZEND_ACC_READONLY);
+
+			// if a class is private or protected, we need to require the correct scope
+			ce->required_scope = propFlags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED) ? CG(active_class_entry) : NULL;
+			ce->required_scope_absolute = propFlags & ZEND_ACC_PRIVATE ? true : false;
+			ce->lexical_scope = CG(active_class_entry);
+
+			// ensure the class is treated as a top-level class and not an anon class
+			toplevel = true;
+		} else {
+			name = zend_prefix_with_ns(unqualified_name);
+			ce->required_scope = NULL;
+			ce->lexical_scope = NULL;
+		}
 		name = zend_new_interned_string(name);
 		lcname = zend_string_tolower(name);
 
@@ -9088,6 +9241,8 @@ static void zend_compile_class_decl(znode *result, zend_ast *ast, bool toplevel)
 		/* Find an anon class name that is not in use yet. */
 		name = NULL;
 		lcname = NULL;
+		ce->required_scope = NULL;
+		ce->lexical_scope = NULL;
 		do {
 			zend_tmp_string_release(name);
 			zend_tmp_string_release(lcname);
@@ -11697,6 +11852,9 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */
 		case ZEND_AST_MATCH:
 			zend_compile_match(result, ast);
 			return;
+		case ZEND_AST_INNER_CLASS:
+			zend_compile_inner_class_ref(result, ast, ZEND_FETCH_CLASS_EXCEPTION);
+			return;
 		default:
 			ZEND_ASSERT(0 /* not supported */);
 	}
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index a7ee8f9327c54..9a95a14e8824d 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -894,6 +894,7 @@ typedef enum {
 	ZEND_MODIFIER_TARGET_CONSTANT,
 	ZEND_MODIFIER_TARGET_CPP,
 	ZEND_MODIFIER_TARGET_PROPERTY_HOOK,
+	ZEND_MODIFIER_TARGET_INNER_CLASS,
 } zend_modifier_target;
 
 /* Used during AST construction */
@@ -1020,6 +1021,7 @@ ZEND_API zend_string *zend_type_to_string(zend_type type);
 #define ZEND_FETCH_CLASS_AUTO		4
 #define ZEND_FETCH_CLASS_INTERFACE	5
 #define ZEND_FETCH_CLASS_TRAIT		6
+#define ZEND_FETCH_CLASS_OUTER		7
 #define ZEND_FETCH_CLASS_MASK        0x0f
 #define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80
 #define ZEND_FETCH_CLASS_SILENT      0x0100
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 6b6af2c225f79..36a9174c5dc0c 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1045,8 +1045,45 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in
 	return zend_verify_scalar_type_hint(type_mask, property, strict, 0);
 }
 
+static zend_always_inline bool zend_check_class_visibility(const zend_class_entry *ce, const zend_property_info *info, uint32_t current_visibility) {
+	// a public class is always visible
+	if (!ce->required_scope) {
+		return 1;
+	}
+
+	// a protected class is visible if it is a subclass of the lexical scope and the current visibility is protected or private
+	if (!ce->required_scope_absolute) {
+		if (current_visibility & ZEND_ACC_PUBLIC) {
+			zend_type_error("Cannot assign protected %s to higher visibile property %s::%s",
+				ZSTR_VAL(ce->name),
+				ZSTR_VAL(info->ce->name),
+				zend_get_unmangled_property_name(info->name));
+			return 0;
+		}
+
+		return 1;
+	}
+
+	// a private class is visible if it is the same class as the lexical scope and the current visibility is private
+	if (ce->required_scope_absolute && current_visibility & ZEND_ACC_PRIVATE) {
+		return 1;
+	}
+
+	zend_type_error("Cannot assign private %s to higher visibile property %s::%s",
+		ZSTR_VAL(ce->name),
+		ZSTR_VAL(info->ce->name),
+		zend_get_unmangled_property_name(info->name));
+
+	return 0;
+}
+
 static zend_always_inline bool i_zend_verify_property_type(const zend_property_info *info, zval *property, bool strict)
 {
+	if(Z_TYPE_P(property) == IS_OBJECT && !zend_check_class_visibility(Z_OBJCE_P(property), info, info->flags)) {
+		zend_verify_property_type_error(info, property);
+		return 0;
+	}
+
 	if (i_zend_check_property_type(info, property, strict)) {
 		return 1;
 	}
@@ -1196,6 +1233,23 @@ static zend_always_inline bool zend_check_type_slow(
 			}
 		} else {
 			ce = zend_fetch_ce_from_cache_slot(cache_slot, type);
+
+			// verify that the class is being used in the correct scope
+			if (ce && ce->required_scope) {
+				zend_class_entry *scope = zend_get_executed_scope();
+				if (ce->required_scope_absolute && scope != ce->required_scope) {
+					if (scope == NULL) {
+						zend_error(E_ERROR, "Private inner class %s cannot be used as a type declaration in the global scope", ZSTR_VAL(ce->name));
+					}
+
+					zend_error(E_ERROR, "Private inner class %s cannot be used as a type declaration in the scope of %s", ZSTR_VAL(ce->name), ZSTR_VAL(scope->name));
+				} else if (scope == NULL) {
+					zend_error(E_ERROR, "Protected inner class %s cannot be used as a type declaration in the global scope", ZSTR_VAL(ce->name));
+				} else if (!instanceof_function(scope, ce->required_scope)) {
+					zend_error(E_ERROR, "Protected inner class %s cannot be used as a type declaration in the scope of %s", ZSTR_VAL(ce->name), ZSTR_VAL(scope->name));
+				}
+			}
+
 			/* If we have a CE we check if it satisfies the type constraint,
 			 * otherwise it will check if a standard type satisfies it. */
 			if (ce && instanceof_function(Z_OBJCE_P(arg), ce)) {
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index c671b3a295e5c..533a1efd3562e 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -231,6 +231,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token T_DOLLAR_OPEN_CURLY_BRACES "'${'"
 %token T_CURLY_OPEN      "'{$'"
 %token T_PAAMAYIM_NEKUDOTAYIM "'::'"
+%token T_INNER_REF       "':>'"
 %token T_NS_SEPARATOR    "'\\'"
 %token T_ELLIPSIS        "'...'"
 %token T_COALESCE        "'??'"
@@ -275,7 +276,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> ctor_arguments alt_if_stmt_without_else trait_adaptation_list lexical_vars
 %type <ast> lexical_var_list encaps_list
 %type <ast> array_pair non_empty_array_pair_list array_pair_list possible_array_pair
-%type <ast> isset_variable type return_type type_expr type_without_static
+%type <ast> isset_variable type return_type type_expr type_without_static inner_type_without_static
 %type <ast> identifier type_expr_without_static union_type_without_static_element union_type_without_static intersection_type_without_static
 %type <ast> inline_function union_type_element union_type intersection_type
 %type <ast> attributed_statement attributed_class_statement attributed_parameter
@@ -284,10 +285,10 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> enum_declaration_statement enum_backing_type enum_case enum_case_expr
 %type <ast> function_name non_empty_member_modifiers
 %type <ast> property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body
-%type <ast> optional_parameter_list
+%type <ast> optional_parameter_list inner_class_statement
 
 %type <num> returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers
-%type <num> method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers
+%type <num> method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers inner_class_modifiers
 %type <num> class_modifiers class_modifier anonymous_class_modifiers anonymous_class_modifiers_optional use_type backup_fn_flags
 
 %type <ptr> backup_lex_pos
@@ -626,6 +627,14 @@ class_modifier:
 	|	T_READONLY 		{ $$ = ZEND_ACC_READONLY_CLASS|ZEND_ACC_NO_DYNAMIC_PROPERTIES; }
 ;
 
+inner_class_modifiers:
+		non_empty_member_modifiers
+			{ $$ = zend_modifier_list_to_flags(ZEND_MODIFIER_TARGET_INNER_CLASS, $1);
+			  if (!$$) { YYERROR; } }
+	|	%empty
+			{ $$ = ZEND_ACC_PUBLIC; }
+;
+
 trait_declaration_statement:
 		T_TRAIT { $<num>$ = CG(zend_lineno); }
 		T_STRING backup_doc_comment '{' class_statement_list '}'
@@ -864,9 +873,16 @@ type_expr_without_static:
 ;
 
 type_without_static:
-		T_ARRAY		{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
-	|	T_CALLABLE	{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
-	|	name		{ $$ = $1; }
+		T_ARRAY						{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); }
+	|	T_CALLABLE					{ $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); }
+	|	inner_type_without_static	{ $$ = $1; }
+;
+
+inner_type_without_static:
+		inner_type_without_static T_INNER_REF name
+			{ $$ = zend_ast_create(ZEND_AST_INNER_CLASS, $1, $3); }
+	| 	name
+			{ $$ = $1; }
 ;
 
 union_type_without_static_element:
@@ -941,6 +957,10 @@ class_statement_list:
 			{ $$ = zend_ast_create_list(0, ZEND_AST_STMT_LIST); }
 ;
 
+inner_class_statement:
+		T_CLASS T_STRING { $<num>$ = CG(zend_lineno); } extends_from implements_list backup_doc_comment '{' class_statement_list '}'
+			{ $$ = zend_ast_create_decl(ZEND_AST_CLASS, 0, $<num>3, $6, zend_ast_get_str($2), $4, $5, $8, NULL, NULL); }
+;
 
 attributed_class_statement:
 		property_modifiers optional_type_without_static property_list ';'
@@ -960,6 +980,8 @@ attributed_class_statement:
 			{ $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1 | $12, $2, $5,
 				  zend_ast_get_str($4), $7, NULL, $11, $9, NULL); CG(extra_fn_flags) = $10; }
 	|	enum_case { $$ = $1; }
+	|	inner_class_modifiers inner_class_statement
+			{ $$ = $2; $$->attr = $1; }
 ;
 
 class_statement:
@@ -1409,12 +1431,14 @@ class_name:
 			{ zval zv; ZVAL_INTERNED_STR(&zv, ZSTR_KNOWN(ZEND_STR_STATIC));
 			  $$ = zend_ast_create_zval_ex(&zv, ZEND_NAME_NOT_FQ); }
 	|	name { $$ = $1; }
+	| class_name T_INNER_REF name
+			{ $$ = zend_ast_create(ZEND_AST_INNER_CLASS, $1, $3); }
 ;
 
 class_name_reference:
-		class_name		{ $$ = $1; }
-	|	new_variable	{ $$ = $1; }
-	|	'(' expr ')'	{ $$ = $2; }
+		class_name	{ $$ = $1; }
+	|	new_variable				{ $$ = $1; }
+	|	'(' expr ')'				{ $$ = $2; }
 ;
 
 backticks_expr:
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 7ae73875926eb..32668d3ee804b 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -1601,6 +1601,10 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN(T_PAAMAYIM_NEKUDOTAYIM);
 }
 
+<ST_IN_SCRIPTING>":>" {
+	RETURN_TOKEN(T_INNER_REF);
+}
+
 <ST_IN_SCRIPTING>"..." {
 	RETURN_TOKEN(T_ELLIPSIS);
 }
diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index f2c2886eeb2be..9a55c0b6e2168 100644
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -381,6 +381,7 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c
 	if (flags & (ZEND_ACC_CHANGED|ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) {
 		zend_class_entry *scope = get_fake_or_executed_scope();
 
+check_lexical_scope:
 		if (property_info->ce != scope) {
 			if (flags & ZEND_ACC_CHANGED) {
 				zend_property_info *p = zend_get_parent_private_property(scope, ce, member);
@@ -402,6 +403,10 @@ static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *c
 					goto dynamic;
 				} else {
 wrong:
+					if (scope && scope->lexical_scope) {
+						scope = scope->lexical_scope;
+						goto check_lexical_scope;
+					}
 					/* Information was available, but we were denied access.  Error out. */
 					if (!silent) {
 						zend_bad_property_access(property_info, ce, member);
@@ -1815,6 +1820,8 @@ ZEND_API zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *
 	/* Check access level */
 	if (fbc->op_array.fn_flags & (ZEND_ACC_CHANGED|ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) {
 		scope = zend_get_executed_scope();
+		zend_class_entry *original_scope = scope;
+check_lexical_scope:
 
 		if (fbc->common.scope != scope) {
 			if (fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
@@ -1832,7 +1839,11 @@ ZEND_API zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *
 				if (zobj->ce->__call) {
 					fbc = zend_get_user_call_function(zobj->ce, method_name);
 				} else {
-					zend_bad_method_call(fbc, method_name, scope);
+					if (scope && scope->lexical_scope) {
+						scope = scope->lexical_scope;
+						goto check_lexical_scope;
+					}
+					zend_bad_method_call(fbc, method_name, original_scope);
 					fbc = NULL;
 				}
 			}
@@ -1891,12 +1902,19 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st
 		fbc = Z_FUNC_P(func);
 		if (!(fbc->op_array.fn_flags & ZEND_ACC_PUBLIC)) {
 			zend_class_entry *scope = zend_get_executed_scope();
+                        zend_class_entry *original_scope = scope;
+check_lexical_scope:
 			if (UNEXPECTED(fbc->common.scope != scope)) {
 				if (UNEXPECTED(fbc->op_array.fn_flags & ZEND_ACC_PRIVATE)
 				 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) {
 					zend_function *fallback_fbc = get_static_method_fallback(ce, function_name);
 					if (!fallback_fbc) {
-						zend_bad_method_call(fbc, function_name, scope);
+						if (scope && scope->lexical_scope) {
+							scope = scope->lexical_scope;
+							goto check_lexical_scope;
+						}
+
+						zend_bad_method_call(fbc, function_name, original_scope);
 					}
 					fbc = fallback_fbc;
 				}
@@ -1973,10 +1991,15 @@ ZEND_API zval *zend_std_get_static_property_with_info(zend_class_entry *ce, zend
 
 	if (!(property_info->flags & ZEND_ACC_PUBLIC)) {
 		zend_class_entry *scope = get_fake_or_executed_scope();
+check_lexical_scope:
 		if (property_info->ce != scope) {
 			if (UNEXPECTED(property_info->flags & ZEND_ACC_PRIVATE)
 			 || UNEXPECTED(!is_protected_compatible_scope(property_info->ce, scope))) {
 				if (type != BP_VAR_IS) {
+					if (scope && scope->lexical_scope) {
+						scope = scope->lexical_scope;
+						goto check_lexical_scope;
+					}
 					zend_bad_property_access(property_info, ce, property_name);
 				}
 				return NULL;
@@ -2057,9 +2080,15 @@ ZEND_API zend_function *zend_std_get_constructor(zend_object *zobj) /* {{{ */
 	if (constructor) {
 		if (UNEXPECTED(!(constructor->op_array.fn_flags & ZEND_ACC_PUBLIC))) {
 			zend_class_entry *scope = get_fake_or_executed_scope();
+check_lexical_scope:
 			if (UNEXPECTED(constructor->common.scope != scope)) {
 				if (UNEXPECTED(constructor->op_array.fn_flags & ZEND_ACC_PRIVATE)
 				 || UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), scope))) {
+					if (scope && scope->lexical_scope) {
+						scope = scope->lexical_scope;
+						goto check_lexical_scope;
+					}
+
 					zend_bad_constructor_call(constructor, scope);
 					zend_object_store_ctor_failed(zobj);
 					constructor = NULL;
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index f32ae13e06793..b5ed1b7a9bc85 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -430,6 +430,10 @@ ZEND_API void destroy_zend_class(zval *zv)
 			if (ce->backed_enum_table) {
 				zend_hash_release(ce->backed_enum_table);
 			}
+			if (ce->required_scope) {
+				ce->required_scope->refcount--;
+				ce->required_scope = NULL;
+			}
 			break;
 		case ZEND_INTERNAL_CLASS:
 			if (ce->doc_comment) {
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 467b5c6193310..b338c988609a2 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1798,6 +1798,108 @@ ZEND_VM_C_LABEL(fetch_this):
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HANDLER(210, ZEND_FETCH_INNER_CLASS, CONST|TMPVAR|UNUSED, CONST, CACHE_SLOT)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_string *inner_class_name, *full_class_name;
+	zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL;
+
+	scope = EX(func)->op_array.scope;
+
+	if (OP1_TYPE == IS_CONST) {
+		zval *outer_class_zv = RT_CONSTANT(opline, opline->op1);
+		outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv));
+		if (!outer_ce) {
+			zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
+			HANDLE_EXCEPTION();
+		}
+	} else if (OP1_TYPE == IS_UNUSED) {
+		uint32_t fetch_type;
+		zend_class_entry *called_scope;
+
+		fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK;
+		if (UNEXPECTED(scope == NULL)) {
+			SAVE_OPLINE();
+			zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
+				fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
+				fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
+			ZVAL_UNDEF(EX_VAR(opline->result.var));
+			HANDLE_EXCEPTION();
+		}
+		if (fetch_type == ZEND_FETCH_CLASS_SELF) {
+			outer_ce = scope;
+		} else if (fetch_type == ZEND_FETCH_CLASS_PARENT) {
+			if (UNEXPECTED(scope->parent == NULL)) {
+				SAVE_OPLINE();
+				zend_throw_error(NULL,
+					"Cannot use \"parent\" when current class scope has no parent");
+				ZVAL_UNDEF(EX_VAR(opline->result.var));
+				HANDLE_EXCEPTION();
+			}
+			outer_ce = scope->parent;
+		} else if (fetch_type == ZEND_FETCH_CLASS_STATIC) {
+			if (Z_TYPE(EX(This)) == IS_OBJECT) {
+				called_scope = Z_OBJCE(EX(This));
+			} else {
+				called_scope = Z_CE(EX(This));
+			}
+			outer_ce = called_scope;
+		} else {
+			zend_throw_error(NULL, "Unknown scope resolution");
+			HANDLE_EXCEPTION();
+		}
+	} else {
+		outer_ce = Z_CE_P(EX_VAR(opline->op1.var));
+	}
+
+	inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+
+	if (UNEXPECTED(ZSTR_LEN(outer_ce->name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) {
+		zend_error(E_ERROR, "Class name is too long");
+		HANDLE_EXCEPTION();
+	}
+
+	full_class_name = zend_string_concat3(
+		ZSTR_VAL(outer_ce->name), ZSTR_LEN(outer_ce->name),
+		":>", 2,
+		ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name)
+	);
+
+	inner_ce = zend_lookup_class(full_class_name);
+	if (!inner_ce) {
+		zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->name));
+		HANDLE_EXCEPTION();
+	}
+
+	if (inner_ce->required_scope) {
+		if (inner_ce->required_scope_absolute) {
+			// for private classes, we check if the scope we are currently in has access
+			if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		} else {
+			// for protected classes, we check if the scope is an instance of the required scope
+			if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		}
+	}
+
+	Z_CE_P(EX_VAR(opline->result.var)) = inner_ce;
+
+	zend_string_release(full_class_name);
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
 {
 	ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_R);
@@ -4427,6 +4529,24 @@ ZEND_VM_COLD_CONST_HANDLER(124, ZEND_VERIFY_RETURN_TYPE, CONST|TMP|VAR|UNUSED|CV
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -8173,6 +8293,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 
 			case ZEND_FETCH_CLASS:
 			case ZEND_DECLARE_ANON_CLASS:
+			case ZEND_FETCH_INNER_CLASS:
 				break; /* return value is zend_class_entry pointer */
 
 			default:
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index e890f94cb08e2..86b9776665d4c 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -3310,6 +3310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(
 
 			case ZEND_FETCH_CLASS:
 			case ZEND_DECLARE_ANON_CLASS:
+			case ZEND_FETCH_INNER_CLASS:
 				break; /* return value is zend_class_entry pointer */
 
 			default:
@@ -6610,6 +6611,108 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CON
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_string *inner_class_name, *full_class_name;
+	zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL;
+
+	scope = EX(func)->op_array.scope;
+
+	if (IS_CONST == IS_CONST) {
+		zval *outer_class_zv = RT_CONSTANT(opline, opline->op1);
+		outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv));
+		if (!outer_ce) {
+			zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
+			HANDLE_EXCEPTION();
+		}
+	} else if (IS_CONST == IS_UNUSED) {
+		uint32_t fetch_type;
+		zend_class_entry *called_scope;
+
+		fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK;
+		if (UNEXPECTED(scope == NULL)) {
+			SAVE_OPLINE();
+			zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
+				fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
+				fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
+			ZVAL_UNDEF(EX_VAR(opline->result.var));
+			HANDLE_EXCEPTION();
+		}
+		if (fetch_type == ZEND_FETCH_CLASS_SELF) {
+			outer_ce = scope;
+		} else if (fetch_type == ZEND_FETCH_CLASS_PARENT) {
+			if (UNEXPECTED(scope->parent == NULL)) {
+				SAVE_OPLINE();
+				zend_throw_error(NULL,
+					"Cannot use \"parent\" when current class scope has no parent");
+				ZVAL_UNDEF(EX_VAR(opline->result.var));
+				HANDLE_EXCEPTION();
+			}
+			outer_ce = scope->parent;
+		} else if (fetch_type == ZEND_FETCH_CLASS_STATIC) {
+			if (Z_TYPE(EX(This)) == IS_OBJECT) {
+				called_scope = Z_OBJCE(EX(This));
+			} else {
+				called_scope = Z_CE(EX(This));
+			}
+			outer_ce = called_scope;
+		} else {
+			zend_throw_error(NULL, "Unknown scope resolution");
+			HANDLE_EXCEPTION();
+		}
+	} else {
+		outer_ce = Z_CE_P(EX_VAR(opline->op1.var));
+	}
+
+	inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+
+	if (UNEXPECTED(ZSTR_LEN(outer_ce->name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) {
+		zend_error(E_ERROR, "Class name is too long");
+		HANDLE_EXCEPTION();
+	}
+
+	full_class_name = zend_string_concat3(
+		ZSTR_VAL(outer_ce->name), ZSTR_LEN(outer_ce->name),
+		":>", 2,
+		ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name)
+	);
+
+	inner_ce = zend_lookup_class(full_class_name);
+	if (!inner_ce) {
+		zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->name));
+		HANDLE_EXCEPTION();
+	}
+
+	if (inner_ce->required_scope) {
+		if (inner_ce->required_scope_absolute) {
+			// for private classes, we check if the scope we are currently in has access
+			if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		} else {
+			// for protected classes, we check if the scope is an instance of the required scope
+			if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		}
+	}
+
+	Z_CE_P(EX_VAR(opline->result.var)) = inner_ce;
+
+	zend_string_release(full_class_name);
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -10799,6 +10902,24 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYP
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -16127,6 +16248,108 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HAN
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_string *inner_class_name, *full_class_name;
+	zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL;
+
+	scope = EX(func)->op_array.scope;
+
+	if ((IS_TMP_VAR|IS_VAR) == IS_CONST) {
+		zval *outer_class_zv = RT_CONSTANT(opline, opline->op1);
+		outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv));
+		if (!outer_ce) {
+			zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
+			HANDLE_EXCEPTION();
+		}
+	} else if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) {
+		uint32_t fetch_type;
+		zend_class_entry *called_scope;
+
+		fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK;
+		if (UNEXPECTED(scope == NULL)) {
+			SAVE_OPLINE();
+			zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
+				fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
+				fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
+			ZVAL_UNDEF(EX_VAR(opline->result.var));
+			HANDLE_EXCEPTION();
+		}
+		if (fetch_type == ZEND_FETCH_CLASS_SELF) {
+			outer_ce = scope;
+		} else if (fetch_type == ZEND_FETCH_CLASS_PARENT) {
+			if (UNEXPECTED(scope->parent == NULL)) {
+				SAVE_OPLINE();
+				zend_throw_error(NULL,
+					"Cannot use \"parent\" when current class scope has no parent");
+				ZVAL_UNDEF(EX_VAR(opline->result.var));
+				HANDLE_EXCEPTION();
+			}
+			outer_ce = scope->parent;
+		} else if (fetch_type == ZEND_FETCH_CLASS_STATIC) {
+			if (Z_TYPE(EX(This)) == IS_OBJECT) {
+				called_scope = Z_OBJCE(EX(This));
+			} else {
+				called_scope = Z_CE(EX(This));
+			}
+			outer_ce = called_scope;
+		} else {
+			zend_throw_error(NULL, "Unknown scope resolution");
+			HANDLE_EXCEPTION();
+		}
+	} else {
+		outer_ce = Z_CE_P(EX_VAR(opline->op1.var));
+	}
+
+	inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+
+	if (UNEXPECTED(ZSTR_LEN(outer_ce->name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) {
+		zend_error(E_ERROR, "Class name is too long");
+		HANDLE_EXCEPTION();
+	}
+
+	full_class_name = zend_string_concat3(
+		ZSTR_VAL(outer_ce->name), ZSTR_LEN(outer_ce->name),
+		":>", 2,
+		ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name)
+	);
+
+	inner_ce = zend_lookup_class(full_class_name);
+	if (!inner_ce) {
+		zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->name));
+		HANDLE_EXCEPTION();
+	}
+
+	if (inner_ce->required_scope) {
+		if (inner_ce->required_scope_absolute) {
+			// for private classes, we check if the scope we are currently in has access
+			if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		} else {
+			// for protected classes, we check if the scope is an instance of the required scope
+			if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		}
+	}
+
+	Z_CE_P(EX_VAR(opline->result.var)) = inner_ce;
+
+	zend_string_release(full_class_name);
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -21536,6 +21759,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_TMP_UN
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -30012,6 +30253,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_VAR_UN
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -33744,6 +34003,108 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	SAVE_OPLINE();
+
+	zend_string *inner_class_name, *full_class_name;
+	zend_class_entry *outer_ce = NULL, *inner_ce = NULL, *scope = NULL;
+
+	scope = EX(func)->op_array.scope;
+
+	if (IS_UNUSED == IS_CONST) {
+		zval *outer_class_zv = RT_CONSTANT(opline, opline->op1);
+		outer_ce = zend_lookup_class(Z_STR_P(outer_class_zv));
+		if (!outer_ce) {
+			zend_error(E_ERROR, "Outer class '%s' not found for inner class %s:>%s", Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(outer_class_zv), Z_STRVAL_P(RT_CONSTANT(opline, opline->op2)));
+			HANDLE_EXCEPTION();
+		}
+	} else if (IS_UNUSED == IS_UNUSED) {
+		uint32_t fetch_type;
+		zend_class_entry *called_scope;
+
+		fetch_type = opline->op1.num & ZEND_FETCH_CLASS_MASK;
+		if (UNEXPECTED(scope == NULL)) {
+			SAVE_OPLINE();
+			zend_throw_error(NULL, "Cannot use \"%s\" in the global scope",
+				fetch_type == ZEND_FETCH_CLASS_SELF ? "self" :
+				fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static");
+			ZVAL_UNDEF(EX_VAR(opline->result.var));
+			HANDLE_EXCEPTION();
+		}
+		if (fetch_type == ZEND_FETCH_CLASS_SELF) {
+			outer_ce = scope;
+		} else if (fetch_type == ZEND_FETCH_CLASS_PARENT) {
+			if (UNEXPECTED(scope->parent == NULL)) {
+				SAVE_OPLINE();
+				zend_throw_error(NULL,
+					"Cannot use \"parent\" when current class scope has no parent");
+				ZVAL_UNDEF(EX_VAR(opline->result.var));
+				HANDLE_EXCEPTION();
+			}
+			outer_ce = scope->parent;
+		} else if (fetch_type == ZEND_FETCH_CLASS_STATIC) {
+			if (Z_TYPE(EX(This)) == IS_OBJECT) {
+				called_scope = Z_OBJCE(EX(This));
+			} else {
+				called_scope = Z_CE(EX(This));
+			}
+			outer_ce = called_scope;
+		} else {
+			zend_throw_error(NULL, "Unknown scope resolution");
+			HANDLE_EXCEPTION();
+		}
+	} else {
+		outer_ce = Z_CE_P(EX_VAR(opline->op1.var));
+	}
+
+	inner_class_name = Z_STR_P(RT_CONSTANT(opline, opline->op2));
+
+	if (UNEXPECTED(ZSTR_LEN(outer_ce->name) + ZSTR_LEN(inner_class_name) + 2 > ZSTR_MAX_LEN)) {
+		zend_error(E_ERROR, "Class name is too long");
+		HANDLE_EXCEPTION();
+	}
+
+	full_class_name = zend_string_concat3(
+		ZSTR_VAL(outer_ce->name), ZSTR_LEN(outer_ce->name),
+		":>", 2,
+		ZSTR_VAL(inner_class_name), ZSTR_LEN(inner_class_name)
+	);
+
+	inner_ce = zend_lookup_class(full_class_name);
+	if (!inner_ce) {
+		zend_error(E_ERROR, "Inner class '%s' not found in outer class %s", ZSTR_VAL(full_class_name), ZSTR_VAL(outer_ce->name));
+		HANDLE_EXCEPTION();
+	}
+
+	if (inner_ce->required_scope) {
+		if (inner_ce->required_scope_absolute) {
+			// for private classes, we check if the scope we are currently in has access
+			if (scope != NULL && (inner_ce->required_scope == scope || scope->lexical_scope == inner_ce->required_scope)) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access private inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		} else {
+			// for protected classes, we check if the scope is an instance of the required scope
+			if (scope != NULL && (instanceof_function(scope, inner_ce->required_scope) || instanceof_function(scope->lexical_scope, inner_ce->required_scope))) {
+				// we are in the correct scope
+			} else {
+				zend_error(E_ERROR, "Cannot access protected inner class '%s'", ZSTR_VAL(full_class_name));
+				HANDLE_EXCEPTION();
+			}
+		}
+	}
+
+	Z_CE_P(EX_VAR(opline->result.var)) = inner_ce;
+
+	zend_string_release(full_class_name);
+
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -37802,6 +38163,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_UNUSED
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -50603,6 +50982,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_VERIFY_RETURN_TYPE_SPEC_CV_UNU
 		}
 
 		SAVE_OPLINE();
+
+		if (Z_TYPE_P(retval_ptr) == IS_OBJECT && Z_OBJCE_P(retval_ptr)->required_scope) {
+			if (EX(func)->common.fn_flags & ZEND_ACC_PUBLIC) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute) {
+					zend_type_error("Public method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				} else {
+					zend_type_error("Public method %s cannot return protected class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			} else if (EX(func)->common.fn_flags & ZEND_ACC_PROTECTED) {
+				if (Z_OBJCE_P(retval_ptr)->required_scope_absolute && Z_OBJCE_P(retval_ptr)->required_scope != EX(func)->common.scope) {
+					zend_type_error("Protected method %s cannot return private class %s", ZSTR_VAL(EX(func)->common.function_name), ZSTR_VAL(Z_OBJCE_P(retval_ptr)->name));
+					HANDLE_EXCEPTION();
+				}
+			}
+		}
+
 		if (UNEXPECTED(!zend_check_type_slow(&ret_info->type, retval_ptr, ref, cache_slot, 1, 0))) {
 			zend_verify_return_error(EX(func), retval_ptr);
 			HANDLE_EXCEPTION();
@@ -57643,6 +58040,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_LABEL,
 			(void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
 			(void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
+			(void*)&&ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_LABEL,
+			(void*)&&ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_LABEL,
+			(void*)&&ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_LABEL,
+			(void*)&&ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_LABEL,
+			(void*)&&ZEND_NULL_LABEL,
 			(void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
 			(void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
@@ -59514,6 +59916,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CONST_CONST)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST):
+				VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST)
+				ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST):
 				VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_CONST)
 				ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -60784,6 +61191,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST):
+				VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST)
+				ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST):
 				VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST)
 				ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -62372,6 +62784,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST):
+				VM_TRACE(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST)
+				ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST):
 				VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST)
 				ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_INLINE_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -66830,6 +67247,11 @@ void zend_vm_init(void)
 		ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER_HANDLER,
 		ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
 		ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
+		ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST_HANDLER,
+		ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER,
+		ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST_HANDLER,
+		ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST_HANDLER,
+		ZEND_NULL_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_HANDLER,
 		ZEND_NULL_HANDLER,
@@ -67787,7 +68209,7 @@ void zend_vm_init(void)
 		1255,
 		1256 | SPEC_RULE_OP1,
 		1261 | SPEC_RULE_OP1,
-		3486,
+		3491,
 		1266 | SPEC_RULE_OP1,
 		1271 | SPEC_RULE_OP1,
 		1276 | SPEC_RULE_OP2,
@@ -67821,7 +68243,7 @@ void zend_vm_init(void)
 		1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1584 | SPEC_RULE_OP1,
 		1589,
-		3486,
+		3491,
 		1590 | SPEC_RULE_OP1,
 		1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
@@ -67952,52 +68374,52 @@ void zend_vm_init(void)
 		2573 | SPEC_RULE_OBSERVER,
 		2575,
 		2576,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
-		3486,
+		2577 | SPEC_RULE_OP1,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
+		3491,
 	};
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
 	zend_opcode_handler_funcs = labels;
@@ -68170,7 +68592,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 = 2585 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2590 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -68178,7 +68600,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 = 2610 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2615 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -68186,7 +68608,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 = 2635 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2640 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -68197,17 +68619,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 = 2660 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2665 | 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 = 2685 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2690 | 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 = 2710 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2715 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_MUL:
@@ -68218,17 +68640,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 = 2735 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2740 | 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 = 2760 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2765 | 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 = 2785 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2790 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_IDENTICAL:
@@ -68239,14 +68661,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 = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2815 | 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 = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2890 | 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 = 3110 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_IDENTICAL:
@@ -68257,14 +68679,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 = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2965 | 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 = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3040 | 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 = 3115 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3120 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_EQUAL:
@@ -68275,12 +68697,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 = 2810 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2815 | 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 = 2885 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2890 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_EQUAL:
@@ -68291,12 +68713,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 = 2960 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2965 | 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 = 3035 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3040 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_SMALLER:
@@ -68304,12 +68726,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 = 3120 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3125 | 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 = 3195 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3200 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
@@ -68317,79 +68739,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3270 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3275 | 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 = 3345 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3350 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_QM_ASSIGN:
 			if (op1_info == MAY_BE_LONG) {
-				spec = 3432 | SPEC_RULE_OP1;
-			} else if (op1_info == MAY_BE_DOUBLE) {
 				spec = 3437 | 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))))) {
+			} else if (op1_info == MAY_BE_DOUBLE) {
 				spec = 3442 | 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 = 3447 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_PRE_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3420 | SPEC_RULE_RETVAL;
+				spec = 3425 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3422 | SPEC_RULE_RETVAL;
+				spec = 3427 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_PRE_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3424 | SPEC_RULE_RETVAL;
+				spec = 3429 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3426 | SPEC_RULE_RETVAL;
+				spec = 3431 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_POST_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3428;
+				spec = 3433;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3429;
+				spec = 3434;
 			}
 			break;
 		case ZEND_POST_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3430;
+				spec = 3435;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3431;
+				spec = 3436;
 			}
 			break;
 		case ZEND_JMP:
 			if (OP_JMP_ADDR(op, op->op1) > op) {
-				spec = 2584;
+				spec = 2589;
 			}
 			break;
 		case ZEND_INIT_FCALL:
 			if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
-				spec = 2577;
+				spec = 2582;
 			}
 			break;
 		case ZEND_RECV:
 			if (op->op2.num == MAY_BE_ANY) {
-				spec = 2578;
+				spec = 2583;
 			}
 			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 = 3482;
+				spec = 3487;
 			}
 			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 = 3477 | SPEC_RULE_OP1;
+				spec = 3482 | 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 = 3484 | SPEC_RULE_RETVAL;
+				spec = 3489 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_FETCH_DIM_R:
@@ -68397,22 +68819,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3447 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 3452 | 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 = 3483;
+				spec = 3488;
 			}
 			break;
 		case ZEND_SEND_VAR:
 			if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3472 | SPEC_RULE_OP1;
+				spec = 3477 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_COUNT:
 			if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
-				spec = 2579 | SPEC_RULE_OP1;
+				spec = 2584 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_BW_OR:
diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 7f3a3cb5de260..e632a82498637 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1372,502 +1372,506 @@
 	_(2574, ZEND_FRAMELESS_ICALL_3_SPEC_OBSERVER) \
 	_(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \
 	_(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \
-	_(2577, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
-	_(2578, ZEND_RECV_NOTYPE_SPEC) \
-	_(2580, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
-	_(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
-	_(2583, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
-	_(2584, ZEND_JMP_FORWARD_SPEC) \
-	_(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2577, ZEND_FETCH_INNER_CLASS_SPEC_CONST_CONST) \
+	_(2578, ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) \
+	_(2579, ZEND_FETCH_INNER_CLASS_SPEC_TMPVAR_CONST) \
+	_(2580, ZEND_FETCH_INNER_CLASS_SPEC_UNUSED_CONST) \
+	_(2582, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
+	_(2583, ZEND_RECV_NOTYPE_SPEC) \
+	_(2585, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2586, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2588, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
+	_(2589, ZEND_JMP_FORWARD_SPEC) \
 	_(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2604, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2612, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2614, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
 	_(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2629, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+	_(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2637, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2639, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2654, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2662, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2664, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
 	_(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2686, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2689, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2679, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2687, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2689, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2691, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2692, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2694, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
 	_(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
 	_(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2711, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2714, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2704, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+	_(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2712, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2714, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2716, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2717, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2719, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
 	_(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2729, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2737, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2739, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2754, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+	_(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2762, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2764, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
 	_(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2779, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2787, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2789, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3114, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3119, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3125, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3126, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3127, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3200, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3201, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3202, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3275, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3276, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3277, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3350, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3351, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3352, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3420, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3421, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3422, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3423, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3424, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3425, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3426, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3427, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3428, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3429, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3430, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3431, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3432, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
-	_(3433, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3434, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3436, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-	_(3438, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3439, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3441, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3442, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-	_(3443, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3444, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3446, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3451, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2804, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2812, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2814, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2857, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2881, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2882, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2887, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2888, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2889, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2932, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2956, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2957, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2962, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2963, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2964, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3007, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3031, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3032, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3037, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3038, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3039, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3082, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3106, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3107, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3112, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3113, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3114, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3115, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3119, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3120, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3124, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3137, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3138, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3140, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3141, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3167, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3186, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3197, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3198, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3242, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3261, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3272, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3273, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3317, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3336, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3347, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3348, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3392, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3411, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3422, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3423, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3425, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3426, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3427, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3428, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3429, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3430, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3431, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3432, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3433, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3434, ZEND_POST_INC_LONG_SPEC_CV) \
+	_(3435, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3436, ZEND_POST_DEC_LONG_SPEC_CV) \
+	_(3437, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
+	_(3438, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3439, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3442, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+	_(3443, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3447, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+	_(3448, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3449, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
 	_(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
 	_(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
 	_(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
 	_(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-	_(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3471, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3474, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-	_(3476, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-	_(3479, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
-	_(3481, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
-	_(3482, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-	_(3483, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-	_(3484, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-	_(3485, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-	_(3485+1, ZEND_NULL)
+	_(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+	_(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+	_(3473, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3479, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+	_(3481, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+	_(3484, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
+	_(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
+	_(3487, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+	_(3488, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+	_(3489, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+	_(3490, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+	_(3490+1, ZEND_NULL)
diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 202dfd3f734f3..b1e6c2950fd6d 100644
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[210] = {
+static const char *zend_vm_opcodes_names[211] = {
 	"ZEND_NOP",
 	"ZEND_ADD",
 	"ZEND_SUB",
@@ -233,9 +233,10 @@ static const char *zend_vm_opcodes_names[210] = {
 	"ZEND_FRAMELESS_ICALL_3",
 	"ZEND_JMP_FRAMELESS",
 	"ZEND_INIT_PARENT_PROPERTY_HOOK_CALL",
+	"ZEND_FETCH_INNER_CLASS",
 };
 
-static uint32_t zend_vm_opcodes_flags[210] = {
+static uint32_t zend_vm_opcodes_flags[211] = {
 	0x00000000,
 	0x00000b0b,
 	0x00000b0b,
@@ -446,6 +447,7 @@ static uint32_t zend_vm_opcodes_flags[210] = {
 	0x00000000,
 	0x01042003,
 	0x01001103,
+	0x00040307,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) {
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index d472b5b9660f5..9734d26ee768e 100644
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -291,7 +291,8 @@ END_EXTERN_C()
 #define ZEND_FRAMELESS_ICALL_3              207
 #define ZEND_JMP_FRAMELESS                  208
 #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209
+#define ZEND_FETCH_INNER_CLASS              210
 
-#define ZEND_VM_LAST_OPCODE                 209
+#define ZEND_VM_LAST_OPCODE                 210
 
 #endif
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 3d45c63a98781..771101462b510 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -1121,6 +1121,27 @@ zend_class_entry *zend_persist_class_entry(zend_class_entry *orig_ce)
 	return ce;
 }
 
+void zend_update_required_scope(zend_class_entry *ce)
+{
+	if (ce->required_scope) {
+		zend_class_entry *required_scope = ce->required_scope;
+
+		zend_class_entry *r = zend_shared_alloc_get_xlat_entry(required_scope);
+		if (r) {
+			ce->required_scope = r;
+		}
+	}
+
+	if (ce->lexical_scope) {
+		zend_class_entry *lexical_scope = ce->lexical_scope;
+
+		zend_class_entry *l = zend_shared_alloc_get_xlat_entry(lexical_scope);
+		if (l) {
+			ce->lexical_scope = l;
+		}
+	}
+}
+
 void zend_update_parent_ce(zend_class_entry *ce)
 {
 	if (ce->ce_flags & ZEND_ACC_LINKED) {
@@ -1294,6 +1315,7 @@ static void zend_accel_persist_class_table(HashTable *class_table)
 		if (EXPECTED(Z_TYPE(p->val) != IS_ALIAS_PTR)) {
 			ce = Z_PTR(p->val);
 			zend_update_parent_ce(ce);
+			zend_update_required_scope(ce);
 		}
 	} ZEND_HASH_FOREACH_END();
 #ifdef HAVE_JIT
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index bc8ffbdd8bd8e..c297426c06d9a 100644
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -4075,6 +4075,56 @@ static void add_class_vars(zend_class_entry *ce, bool statics, zval *return_valu
 }
 /* }}} */
 
+/* {{{ Returns whether the current class is an inner class */
+ZEND_METHOD(ReflectionClass, isInnerClass)
+{
+	reflection_object *intern;
+  zend_class_entry *ce;
+
+  ZEND_PARSE_PARAMETERS_NONE();
+
+  GET_REFLECTION_OBJECT_PTR(ce);
+
+  // If the class is an inner class, it will have a T_INNER_REF in its name
+  // todo: make this better?
+
+  RETURN_BOOL(strstr(ZSTR_VAL(ce->name), ":>") != NULL);
+}
+/* }}} */
+
+/* {{{ Returns true if the class is private */
+ZEND_METHOD(ReflectionClass, isPrivate)
+{
+    reflection_object *intern;
+    zend_class_entry *ce;
+
+    ZEND_PARSE_PARAMETERS_NONE();
+    GET_REFLECTION_OBJECT_PTR(ce);
+    RETURN_BOOL(ce->required_scope && ce->required_scope_absolute);
+}
+
+/* {{{ Returns true if the class is protected */
+ZEND_METHOD(ReflectionClass, isProtected)
+{
+    reflection_object *intern;
+    zend_class_entry *ce;
+
+    ZEND_PARSE_PARAMETERS_NONE();
+    GET_REFLECTION_OBJECT_PTR(ce);
+    RETURN_BOOL(ce->required_scope && !ce->required_scope_absolute);
+}
+
+/* {{{ Returns true if the class is public */
+ZEND_METHOD(ReflectionClass, isPublic)
+{
+    reflection_object *intern;
+    zend_class_entry *ce;
+
+    ZEND_PARSE_PARAMETERS_NONE();
+    GET_REFLECTION_OBJECT_PTR(ce);
+    RETURN_BOOL(!ce->required_scope);
+}
+
 /* {{{ Returns an associative array containing all static property values of the class */
 ZEND_METHOD(ReflectionClass, getStaticProperties)
 {
diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php
index be511d7ee14cd..6b03c6deb03c8 100644
--- a/ext/reflection/php_reflection.stub.php
+++ b/ext/reflection/php_reflection.stub.php
@@ -432,6 +432,14 @@ public function getNamespaceName(): string {}
     public function getShortName(): string {}
 
     public function getAttributes(?string $name = null, int $flags = 0): array {}
+
+    public function isInnerClass(): bool {}
+
+    public function isPrivate(): bool {}
+
+    public function isProtected(): bool {}
+
+    public function isPublic(): bool {}
 }
 
 class ReflectionObject extends ReflectionClass
diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h
index d78a685dde9c9..9630754e93c27 100644
--- a/ext/reflection/php_reflection_arginfo.h
+++ b/ext/reflection/php_reflection_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 3c6be99bb36965139464925a618cb0bf03affa62 */
+ * Stub hash: be0cae939aa05863ce2206767bbb923ea9951dd7 */
 
 ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_Reflection_getModifierNames, 0, 1, IS_ARRAY, 0)
 	ZEND_ARG_TYPE_INFO(0, modifiers, IS_LONG, 0)
@@ -366,6 +366,14 @@ ZEND_END_ARG_INFO()
 
 #define arginfo_class_ReflectionClass_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes
 
+#define arginfo_class_ReflectionClass_isInnerClass arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType
+
+#define arginfo_class_ReflectionClass_isPrivate arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType
+
+#define arginfo_class_ReflectionClass_isProtected arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType
+
+#define arginfo_class_ReflectionClass_isPublic arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType
+
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionObject___construct, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, object, IS_OBJECT, 0)
 ZEND_END_ARG_INFO()
@@ -847,6 +855,10 @@ ZEND_METHOD(ReflectionClass, inNamespace);
 ZEND_METHOD(ReflectionClass, getNamespaceName);
 ZEND_METHOD(ReflectionClass, getShortName);
 ZEND_METHOD(ReflectionClass, getAttributes);
+ZEND_METHOD(ReflectionClass, isInnerClass);
+ZEND_METHOD(ReflectionClass, isPrivate);
+ZEND_METHOD(ReflectionClass, isProtected);
+ZEND_METHOD(ReflectionClass, isPublic);
 ZEND_METHOD(ReflectionObject, __construct);
 ZEND_METHOD(ReflectionProperty, __construct);
 ZEND_METHOD(ReflectionProperty, __toString);
@@ -1139,6 +1151,10 @@ static const zend_function_entry class_ReflectionClass_methods[] = {
 	ZEND_ME(ReflectionClass, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getShortName, arginfo_class_ReflectionClass_getShortName, ZEND_ACC_PUBLIC)
 	ZEND_ME(ReflectionClass, getAttributes, arginfo_class_ReflectionClass_getAttributes, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionClass, isInnerClass, arginfo_class_ReflectionClass_isInnerClass, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionClass, isPrivate, arginfo_class_ReflectionClass_isPrivate, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionClass, isProtected, arginfo_class_ReflectionClass_isProtected, ZEND_ACC_PUBLIC)
+	ZEND_ME(ReflectionClass, isPublic, arginfo_class_ReflectionClass_isPublic, ZEND_ACC_PUBLIC)
 	ZEND_FE_END
 };
 
diff --git a/ext/reflection/tests/ReflectionClass_toString_001.phpt b/ext/reflection/tests/ReflectionClass_toString_001.phpt
index fd5d83e917419..2a77633245d03 100644
--- a/ext/reflection/tests/ReflectionClass_toString_001.phpt
+++ b/ext/reflection/tests/ReflectionClass_toString_001.phpt
@@ -30,7 +30,7 @@ Class [ <internal:Reflection> class ReflectionClass implements Stringable, Refle
     Property [ public string $name ]
   }
 
-  - Methods [64] {
+  - Methods [68] {
     Method [ <internal:Reflection> private method __clone ] {
 
       - Parameters [0] {
@@ -514,5 +514,33 @@ Class [ <internal:Reflection> class ReflectionClass implements Stringable, Refle
       }
       - Return [ array ]
     }
+
+    Method [ <internal:Reflection> public method isInnerClass ] {
+
+      - Parameters [0] {
+      }
+      - Return [ bool ]
+    }
+
+    Method [ <internal:Reflection> public method isPrivate ] {
+
+      - Parameters [0] {
+      }
+      - Return [ bool ]
+    }
+
+    Method [ <internal:Reflection> public method isProtected ] {
+
+      - Parameters [0] {
+      }
+      - Return [ bool ]
+    }
+
+    Method [ <internal:Reflection> public method isPublic ] {
+
+      - Parameters [0] {
+      }
+      - Return [ bool ]
+    }
   }
 }
diff --git a/ext/reflection/tests/bug74454.phpt b/ext/reflection/tests/bug74454.phpt
index 272409339c479..f1116becf6ce8 100644
--- a/ext/reflection/tests/bug74454.phpt
+++ b/ext/reflection/tests/bug74454.phpt
@@ -14,4 +14,4 @@ function load_file() {
 }
 ?>
 --EXPECT--
-ParseError: syntax error, unexpected token "if", expecting "function"
+ParseError: syntax error, unexpected token "if", expecting "class"
diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index a046ab50e1498..59da06bc0bf17 100644
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -167,6 +167,7 @@ char *get_token_type_name(int token_type)
 		case T_DOLLAR_OPEN_CURLY_BRACES: return "T_DOLLAR_OPEN_CURLY_BRACES";
 		case T_CURLY_OPEN: return "T_CURLY_OPEN";
 		case T_PAAMAYIM_NEKUDOTAYIM: return "T_DOUBLE_COLON";
+		case T_INNER_REF: return "T_INNER_REF";
 		case T_NS_SEPARATOR: return "T_NS_SEPARATOR";
 		case T_ELLIPSIS: return "T_ELLIPSIS";
 		case T_COALESCE: return "T_COALESCE";
diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php
index 45f3c89f2de3a..ba9421aa65ae7 100644
--- a/ext/tokenizer/tokenizer_data.stub.php
+++ b/ext/tokenizer/tokenizer_data.stub.php
@@ -712,6 +712,11 @@
  * @cvalue T_PAAMAYIM_NEKUDOTAYIM
  */
 const T_PAAMAYIM_NEKUDOTAYIM = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_INNER_REF
+ */
+const T_INNER_REF = UNKNOWN;
 /**
  * @var int
  * @cvalue T_NS_SEPARATOR
diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h
index 61f6ac1ec3659..a50c5de80c790 100644
--- a/ext/tokenizer/tokenizer_data_arginfo.h
+++ b/ext/tokenizer/tokenizer_data_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: d917cab61a2b436a16d2227cdb438add45e42d69 */
+ * Stub hash: b9b93f604bff8f299fa3e008db9f61fccd603686 */
 
 static void register_tokenizer_data_symbols(int module_number)
 {
@@ -145,6 +145,7 @@ static void register_tokenizer_data_symbols(int module_number)
 	REGISTER_LONG_CONSTANT("T_DOLLAR_OPEN_CURLY_BRACES", T_DOLLAR_OPEN_CURLY_BRACES, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CURLY_OPEN", T_CURLY_OPEN, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_PAAMAYIM_NEKUDOTAYIM", T_PAAMAYIM_NEKUDOTAYIM, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_INNER_REF", T_INNER_REF, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_NS_SEPARATOR", T_NS_SEPARATOR, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_ELLIPSIS", T_ELLIPSIS, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_COALESCE", T_COALESCE, CONST_PERSISTENT);
diff --git a/tests/classes/inner_classes/access_modifiers_001.phpt b/tests/classes/inner_classes/access_modifiers_001.phpt
new file mode 100644
index 0000000000000..ac1ce71cd3d40
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_001.phpt
@@ -0,0 +1,13 @@
+--TEST--
+multiple access modifiers
+--FILE--
+<?php
+
+class Outer {
+    public private class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Multiple access type modifiers are not allowed in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_002.phpt b/tests/classes/inner_classes/access_modifiers_002.phpt
new file mode 100644
index 0000000000000..9c9eee89387b0
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_002.phpt
@@ -0,0 +1,13 @@
+--TEST--
+invalid inner class
+--FILE--
+<?php
+
+class Outer {
+    int class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Parse error: syntax error, unexpected identifier "int", expecting "class" in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_003.phpt b/tests/classes/inner_classes/access_modifiers_003.phpt
new file mode 100644
index 0000000000000..3dd79008daa60
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_003.phpt
@@ -0,0 +1,13 @@
+--TEST--
+static access modifiers
+--FILE--
+<?php
+
+class Outer {
+    static class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use the static modifier on a inner class in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_004.phpt b/tests/classes/inner_classes/access_modifiers_004.phpt
new file mode 100644
index 0000000000000..a4e86484ed9ec
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_004.phpt
@@ -0,0 +1,13 @@
+--TEST--
+public(set) inner class
+--FILE--
+<?php
+
+class Outer {
+    public(set) class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use the public(set) modifier on a inner class in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_005.phpt b/tests/classes/inner_classes/access_modifiers_005.phpt
new file mode 100644
index 0000000000000..82d7f0e93676c
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_005.phpt
@@ -0,0 +1,13 @@
+--TEST--
+protected(set) inner class
+--FILE--
+<?php
+
+class Outer {
+    protected(set) class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use the protected(set) modifier on a inner class in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_006.phpt b/tests/classes/inner_classes/access_modifiers_006.phpt
new file mode 100644
index 0000000000000..41266b10b453f
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_006.phpt
@@ -0,0 +1,13 @@
+--TEST--
+private(set) inner class
+--FILE--
+<?php
+
+class Outer {
+    private(set) class Inner {
+    }
+}
+
+?>
+--EXPECTF--
+Fatal error: Cannot use the private(set) modifier on a inner class in %s on line %d
diff --git a/tests/classes/inner_classes/access_modifiers_007.phpt b/tests/classes/inner_classes/access_modifiers_007.phpt
new file mode 100644
index 0000000000000..d1177412939f1
--- /dev/null
+++ b/tests/classes/inner_classes/access_modifiers_007.phpt
@@ -0,0 +1,27 @@
+--TEST--
+abstract inner classes
+--FILE--
+<?php
+
+class Outer {
+    public abstract class Inner {}
+}
+
+class Extended extends Outer:>Inner {}
+
+$extended = new Extended();
+
+var_dump($extended);
+$reflection = new ReflectionClass('Outer:>Inner');
+var_dump($reflection->isAbstract());
+new Outer:>Inner();
+?>
+--EXPECTF--
+object(Extended)#1 (0) {
+}
+bool(true)
+
+Fatal error: Uncaught Error: Cannot instantiate abstract class Outer:>Inner in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/autoload_001.phpt b/tests/classes/inner_classes/autoload_001.phpt
new file mode 100644
index 0000000000000..eef4cdfa5de09
--- /dev/null
+++ b/tests/classes/inner_classes/autoload_001.phpt
@@ -0,0 +1,15 @@
+--TEST--
+ensure autoloading works
+--FILE--
+<?php
+spl_autoload_register(static function ($class_name) {
+    require_once(__DIR__ . '/' . $class_name . '.inc');
+    echo 'autoload(' . $class_name . ")\n";
+});
+
+$point = new inner_classes:>Point(1, 2);
+echo $point->x, ' ', $point->y, "\n";
+?>
+--EXPECT--
+autoload(inner_classes)
+1 2
diff --git a/tests/classes/inner_classes/autoload_002.phpt b/tests/classes/inner_classes/autoload_002.phpt
new file mode 100644
index 0000000000000..f2cbd1fc6cc74
--- /dev/null
+++ b/tests/classes/inner_classes/autoload_002.phpt
@@ -0,0 +1,16 @@
+--TEST--
+ensure private autoloading works
+--FILE--
+<?php
+spl_autoload_register(static function ($class_name) {
+    require_once(__DIR__ . '/' . $class_name . '.inc');
+    echo 'autoload(' . $class_name . ")\n";
+});
+
+$line = new inner_classes:>Line();
+var_dump($line);
+?>
+--EXPECTF--
+autoload(inner_classes)
+
+Fatal error: Cannot access private inner class 'inner_classes:>Line' in %s
diff --git a/tests/classes/inner_classes/enum_usage.phpt b/tests/classes/inner_classes/enum_usage.phpt
new file mode 100644
index 0000000000000..d96533aa54a38
--- /dev/null
+++ b/tests/classes/inner_classes/enum_usage.phpt
@@ -0,0 +1,16 @@
+--TEST--
+usage in an enum
+--FILE--
+<?php
+
+enum Outer {
+    class Inner {}
+}
+
+var_dump(new Outer:>Inner());
+var_dump(class_exists(Outer:>Inner::class));
+?>
+--EXPECT--
+object(Outer:>Inner)#1 (0) {
+}
+bool(true)
diff --git a/tests/classes/inner_classes/errors_001.phpt b/tests/classes/inner_classes/errors_001.phpt
new file mode 100644
index 0000000000000..f4817e95351ce
--- /dev/null
+++ b/tests/classes/inner_classes/errors_001.phpt
@@ -0,0 +1,9 @@
+--TEST--
+no outer class
+--FILE--
+<?php
+
+new Outer:>Inner();
+?>
+--EXPECTF--
+Fatal error: Outer class 'Outer' not found for inner class Outer:>Inner in %s on line %d
diff --git a/tests/classes/inner_classes/errors_002.phpt b/tests/classes/inner_classes/errors_002.phpt
new file mode 100644
index 0000000000000..c9e1c08147675
--- /dev/null
+++ b/tests/classes/inner_classes/errors_002.phpt
@@ -0,0 +1,12 @@
+--TEST--
+inner class not found
+--FILE--
+<?php
+
+class Outer {
+}
+
+new Outer:>Inner();
+?>
+--EXPECTF--
+Fatal error: Inner class 'Outer:>Inner' not found in outer class Outer in %s on line %d
diff --git a/tests/classes/inner_classes/inheritance.phpt b/tests/classes/inner_classes/inheritance.phpt
new file mode 100644
index 0000000000000..4addb7b02f61d
--- /dev/null
+++ b/tests/classes/inner_classes/inheritance.phpt
@@ -0,0 +1,14 @@
+--TEST--
+inheritance
+--FILE--
+<?php
+
+class Outer {
+    abstract class Other {}
+    class Middle extends Outer:>Other {
+        class Inner1 extends Outer:>Other {}
+        class Inner2 extends Outer:>Middle {}
+    }
+}
+?>
+--EXPECT--
diff --git a/tests/classes/inner_classes/inner_classes.inc b/tests/classes/inner_classes/inner_classes.inc
new file mode 100644
index 0000000000000..793804cf6606e
--- /dev/null
+++ b/tests/classes/inner_classes/inner_classes.inc
@@ -0,0 +1,9 @@
+<?php
+
+class inner_classes {
+    public class Point {
+        public function __construct(public int $x, public int $y) {}
+    }
+
+    private class Line {}
+}
diff --git a/tests/classes/inner_classes/interface_usage.phpt b/tests/classes/inner_classes/interface_usage.phpt
new file mode 100644
index 0000000000000..2d3a071531d0a
--- /dev/null
+++ b/tests/classes/inner_classes/interface_usage.phpt
@@ -0,0 +1,21 @@
+--TEST--
+usage in an interface
+--FILE--
+<?php
+
+interface Outer {
+    class Inner {}
+}
+
+var_dump(new Outer:>Inner());
+
+class Foo implements Outer {}
+
+var_dump(class_exists(Outer:>Inner::class));
+var_dump(class_exists(Foo:>Inner::class));
+?>
+--EXPECT--
+object(Outer:>Inner)#1 (0) {
+}
+bool(true)
+bool(false)
diff --git a/tests/classes/inner_classes/readonly_001.phpt b/tests/classes/inner_classes/readonly_001.phpt
new file mode 100644
index 0000000000000..189c9bcb23b7d
--- /dev/null
+++ b/tests/classes/inner_classes/readonly_001.phpt
@@ -0,0 +1,23 @@
+--TEST--
+readonly should work
+--FILE--
+<?php
+
+class Outer {
+    public readonly class Inner { public function __construct(public int $t) {} }
+}
+
+var_dump($foo = new Outer:>Inner(1));
+$foo->t = 42;
+var_dump($foo);
+?>
+--EXPECTF--
+object(Outer:>Inner)#1 (1) {
+  ["t"]=>
+  int(1)
+}
+
+Fatal error: Uncaught Error: Cannot modify readonly property Outer:>Inner::$t in %s:%d
+Stack trace:
+#0 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/reflection_001.phpt b/tests/classes/inner_classes/reflection_001.phpt
new file mode 100644
index 0000000000000..0f1f53bae838e
--- /dev/null
+++ b/tests/classes/inner_classes/reflection_001.phpt
@@ -0,0 +1,31 @@
+--TEST--
+reflection on inner classes
+--FILE--
+<?php
+
+namespace n\s;
+
+class Outer {
+    class Middle {
+        class Inner {}
+    }
+}
+
+$outer = new \ReflectionClass(Outer::class);
+$ref = new \ReflectionClass('n\s\Outer:>Middle:>Inner');
+var_dump($ref->getName());
+var_dump($ref->getShortName());
+var_dump($ref->isInnerClass());
+var_dump($outer->isInnerClass());
+var_dump($ref->isPrivate());
+var_dump($ref->isProtected());
+var_dump($ref->isPublic());
+?>
+--EXPECT--
+string(24) "n\s\Outer:>Middle:>Inner"
+string(20) "Outer:>Middle:>Inner"
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
diff --git a/tests/classes/inner_classes/return_types_001.phpt b/tests/classes/inner_classes/return_types_001.phpt
new file mode 100644
index 0000000000000..d7190df3644d0
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_001.phpt
@@ -0,0 +1,18 @@
+--TEST--
+test return types
+--FILE--
+<?php
+
+class Outer {
+    class Inner {
+        public static function test(): Outer:>Inner {
+            return new Outer:>Inner();
+        }
+    }
+}
+
+var_dump(Outer:>Inner::test());
+?>
+--EXPECT--
+object(Outer:>Inner)#1 (0) {
+}
diff --git a/tests/classes/inner_classes/return_types_002.phpt b/tests/classes/inner_classes/return_types_002.phpt
new file mode 100644
index 0000000000000..b2929a6fdd148
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_002.phpt
@@ -0,0 +1,32 @@
+--TEST--
+private inner class
+--FILE--
+<?php
+
+class Outer {
+    private class Inner {}
+
+    private function getInner(): self:>Inner {
+        return new self:>Inner();
+    }
+
+    public function getInner2(): mixed {
+        return $this->getInner();
+    }
+}
+
+class Foo extends Outer {
+    public function getInner(): parent:>Inner {
+        var_dump(parent::getInner2());
+        return new parent:>Inner();
+    }
+}
+
+$outer = new Foo();
+var_dump($outer->getInner());
+?>
+--EXPECTF--
+object(Outer:>Inner)#2 (0) {
+}
+
+Fatal error: Cannot access private inner class 'Outer:>Inner' in %s on line %d
diff --git a/tests/classes/inner_classes/return_types_003.phpt b/tests/classes/inner_classes/return_types_003.phpt
new file mode 100644
index 0000000000000..4326566956ca2
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_003.phpt
@@ -0,0 +1,33 @@
+--TEST--
+protected inner class
+--FILE--
+<?php
+
+class Outer {
+    protected class Inner {}
+
+    protected function getInner(): self:>Inner {
+        return new self:>Inner();
+    }
+}
+
+class Foo extends Outer {
+    public function getInner(): parent:>Inner {
+        var_dump(parent::getInner());
+        return new parent:>Inner();
+    }
+}
+
+$outer = new Foo();
+var_dump($outer->getInner());
+var_dump(new Outer:>Inner());
+?>
+--EXPECTF--
+object(Outer:>Inner)#2 (0) {
+}
+
+Fatal error: Uncaught TypeError: Public method getInner cannot return protected class Outer:>Inner in %s:%d
+Stack trace:
+#0 %s(%d): Foo->getInner()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/return_types_004.phpt b/tests/classes/inner_classes/return_types_004.phpt
new file mode 100644
index 0000000000000..0fbeacd246297
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_004.phpt
@@ -0,0 +1,26 @@
+--TEST--
+private return types
+--FILE--
+<?php
+
+class Outer {
+    private class Inner {}
+
+    public static function getInner(): self:>Inner {
+        return new self:>Inner();
+    }
+}
+
+$r = Outer::getInner();
+function test($r): Outer:>Inner {
+    return $r;
+}
+var_dump($r);
+test($r);
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Public method getInner cannot return private class Outer:>Inner in %s:%d
+Stack trace:
+#0 %s(%d): Outer::getInner()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/return_types_005.phpt b/tests/classes/inner_classes/return_types_005.phpt
new file mode 100644
index 0000000000000..5c2ed4ae7de86
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_005.phpt
@@ -0,0 +1,26 @@
+--TEST--
+protected return types
+--FILE--
+<?php
+
+class Outer {
+    protected class Inner {}
+
+    public static function getInner(): self:>Inner {
+        return new self:>Inner();
+    }
+}
+
+$r = Outer::getInner();
+function test($r): Outer:>Inner {
+    return $r;
+}
+var_dump($r);
+test($r);
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Public method getInner cannot return protected class Outer:>Inner in %s:%d
+Stack trace:
+#0 %s(%d): Outer::getInner()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/return_types_006.phpt b/tests/classes/inner_classes/return_types_006.phpt
new file mode 100644
index 0000000000000..cff19b727ad54
--- /dev/null
+++ b/tests/classes/inner_classes/return_types_006.phpt
@@ -0,0 +1,21 @@
+--TEST--
+returning private inner from inner method
+--FILE--
+<?php
+
+class Outer {
+    private class PrivateInner {
+        public function test() {
+            return new Outer:>PrivateInner();
+        }
+    }
+
+    public function test(): mixed { return new self:>PrivateInner()->test(); }
+}
+
+$foo = new Outer()->test();
+var_dump($foo);
+?>
+--EXPECT--
+object(Outer:>PrivateInner)#3 (0) {
+}
diff --git a/tests/classes/inner_classes/simple_declaration_001.phpt b/tests/classes/inner_classes/simple_declaration_001.phpt
new file mode 100644
index 0000000000000..8b53dd3b089b2
--- /dev/null
+++ b/tests/classes/inner_classes/simple_declaration_001.phpt
@@ -0,0 +1,21 @@
+--TEST--
+simple declaration
+--FILE--
+<?php
+
+class Outer {
+    class Middle {
+        class Inner {}
+    }
+}
+
+var_dump(class_exists('Outer:>Middle'));
+var_dump(class_exists('Outer:>Middle:>Inner'));
+var_dump(class_exists(Outer:>Middle::class));
+var_dump(class_exists(Outer:>Middle:>Inner::class));
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(true)
diff --git a/tests/classes/inner_classes/simple_declaration_002.phpt b/tests/classes/inner_classes/simple_declaration_002.phpt
new file mode 100644
index 0000000000000..d129f17a7b0a5
--- /dev/null
+++ b/tests/classes/inner_classes/simple_declaration_002.phpt
@@ -0,0 +1,13 @@
+--TEST--
+nested inside function
+--FILE--
+<?php
+
+class Outer {
+    public function test() {
+        class Inner {}
+    }
+}
+?>
+--EXPECTF--
+Fatal error: Class declarations may not be declared inside functions in %s on line %d
diff --git a/tests/classes/inner_classes/simple_declaration_003.phpt b/tests/classes/inner_classes/simple_declaration_003.phpt
new file mode 100644
index 0000000000000..13c84de709caa
--- /dev/null
+++ b/tests/classes/inner_classes/simple_declaration_003.phpt
@@ -0,0 +1,20 @@
+--TEST--
+basic nested classes
+--FILE--
+<?php
+
+namespace Foo;
+
+class Outer {
+    class Middle {
+        class Inner {
+            public function test() {
+                echo __CLASS__;
+            }
+        }
+    }
+}
+new Outer:>Middle:>Inner()->test();
+?>
+--EXPECT--
+Foo\Outer:>Middle:>Inner
diff --git a/tests/classes/inner_classes/simple_declaration_004.phpt b/tests/classes/inner_classes/simple_declaration_004.phpt
new file mode 100644
index 0000000000000..898045a3ee606
--- /dev/null
+++ b/tests/classes/inner_classes/simple_declaration_004.phpt
@@ -0,0 +1,41 @@
+--TEST--
+scope resolution access
+--FILE--
+<?php
+
+class Outer {
+    public class Middle {
+    }
+    public static function testSelf(): self:>Middle {
+        return new self:>Middle();
+    }
+}
+
+class Outer2 extends Outer {
+    public class Middle extends parent:>Middle {
+    }
+
+    public static function testParent(): parent:>Middle {
+        return new parent:>Middle();
+    }
+
+    public static function testSelf(): self:>Middle {
+        return new self:>Middle();
+    }
+}
+
+var_dump(Outer::testSelf());
+var_dump(Outer2::testParent());
+var_dump(Outer2::testSelf());
+var_dump(Outer2::testSelf());
+
+?>
+--EXPECT--
+object(Outer:>Middle)#1 (0) {
+}
+object(Outer:>Middle)#1 (0) {
+}
+object(Outer2:>Middle)#1 (0) {
+}
+object(Outer2:>Middle)#1 (0) {
+}
diff --git a/tests/classes/inner_classes/static_resolution.phpt b/tests/classes/inner_classes/static_resolution.phpt
new file mode 100644
index 0000000000000..e67ed0cf65e6a
--- /dev/null
+++ b/tests/classes/inner_classes/static_resolution.phpt
@@ -0,0 +1,16 @@
+--TEST--
+static resolution
+--FILE--
+<?php
+
+class Outer {
+    class Inner {}
+
+    public function test() {
+        return new static:>Inner();
+    }
+}
+var_dump(new Outer()->test());
+?>
+--EXPECTF--
+Fatal error: Cannot use the static modifier on an inner class in %s on line %d
diff --git a/tests/classes/inner_classes/static_variables.phpt b/tests/classes/inner_classes/static_variables.phpt
new file mode 100644
index 0000000000000..e656a9648a2ca
--- /dev/null
+++ b/tests/classes/inner_classes/static_variables.phpt
@@ -0,0 +1,30 @@
+--TEST--
+::class, statics, and inner classes
+--FILE--
+<?php
+
+class Outer {
+    class Middle {
+        public const FOO = 'foo';
+        public static int $bar = 42;
+        class Inner {
+            public const FOO = 'foo';
+            public static int $bar = 42;
+        }
+    }
+}
+
+var_dump(Outer:>Middle::class);
+var_dump(Outer:>Middle::FOO);
+var_dump(Outer:>Middle::$bar);
+var_dump(Outer:>Middle:>Inner::class);
+var_dump(Outer:>Middle:>Inner::FOO);
+var_dump(Outer:>Middle:>Inner::$bar);
+?>
+--EXPECT--
+string(13) "Outer:>Middle"
+string(3) "foo"
+int(42)
+string(20) "Outer:>Middle:>Inner"
+string(3) "foo"
+int(42)
diff --git a/tests/classes/inner_classes/trait_usage.phpt b/tests/classes/inner_classes/trait_usage.phpt
new file mode 100644
index 0000000000000..1511b8a642214
--- /dev/null
+++ b/tests/classes/inner_classes/trait_usage.phpt
@@ -0,0 +1,24 @@
+--TEST--
+usage inside a trait
+--FILE--
+<?php
+
+trait Outer {
+    class Inner {}
+}
+
+var_dump(new Outer:>Inner());
+
+class Foo {
+    use Outer;
+}
+
+var_dump(class_exists(Outer:>Inner::class));
+var_dump(class_exists(Foo:>Inner::class));
+
+?>
+--EXPECT--
+object(Outer:>Inner)#1 (0) {
+}
+bool(true)
+bool(false)
diff --git a/tests/classes/inner_classes/visibility_001.phpt b/tests/classes/inner_classes/visibility_001.phpt
new file mode 100644
index 0000000000000..0473686689403
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_001.phpt
@@ -0,0 +1,25 @@
+--TEST--
+outer class visibility
+--FILE--
+<?php
+
+class Outer {
+        private class Inner {}
+        public Outer:>Inner $illegal;
+
+        public function test(): void {
+                $this->illegal = new Outer:>Inner();
+        }
+}
+
+$x = new Outer();
+$x->test();
+
+var_dump($x);
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Cannot assign private Outer:>Inner to higher visibile property Outer::illegal in %s:%d
+Stack trace:
+#0 %s(%d): Outer->test()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/visibility_002.phpt b/tests/classes/inner_classes/visibility_002.phpt
new file mode 100644
index 0000000000000..8e99b87d15a15
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_002.phpt
@@ -0,0 +1,30 @@
+--TEST--
+accessing outer class private vars
+--FILE--
+<?php
+
+class Outer {
+        private class Inner {
+                public function test(Outer $i) {
+                        $i->illegal = $this;
+                }
+        }
+        private Outer:>Inner $illegal;
+
+        public function test(): void {
+                new Outer:>Inner()->test($this);
+        }
+}
+
+$x = new Outer();
+$x->test();
+
+var_dump($x);
+
+?>
+--EXPECT--
+object(Outer)#1 (1) {
+  ["illegal":"Outer":private]=>
+  object(Outer:>Inner)#2 (0) {
+  }
+}
diff --git a/tests/classes/inner_classes/visibility_003.phpt b/tests/classes/inner_classes/visibility_003.phpt
new file mode 100644
index 0000000000000..66f42b2707838
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_003.phpt
@@ -0,0 +1,30 @@
+--TEST--
+accessing outer protected vars
+--FILE--
+<?php
+
+class Outer {
+        private class Inner {
+                public function test(Outer $i) {
+                        $i->illegal = $this;
+                }
+        }
+        private Outer:>Inner $illegal;
+
+        public function test(): void {
+                new Outer:>Inner()->test($this);
+        }
+}
+
+$x = new Outer();
+$x->test();
+
+var_dump($x);
+
+?>
+--EXPECT--
+object(Outer)#1 (1) {
+  ["illegal":"Outer":private]=>
+  object(Outer:>Inner)#2 (0) {
+  }
+}
diff --git a/tests/classes/inner_classes/visibility_004.phpt b/tests/classes/inner_classes/visibility_004.phpt
new file mode 100644
index 0000000000000..38390f65c830e
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_004.phpt
@@ -0,0 +1,25 @@
+--TEST--
+outer class visibility
+--FILE--
+<?php
+
+class Outer {
+        protected class Inner {}
+        public Outer:>Inner $illegal;
+
+        public function test(): void {
+                $this->illegal = new Outer:>Inner();
+        }
+}
+
+$x = new Outer();
+$x->test();
+
+var_dump($x);
+?>
+--EXPECTF--
+Fatal error: Uncaught TypeError: Cannot assign protected Outer:>Inner to higher visibile property Outer::illegal in %s:%d
+Stack trace:
+#0 %s(%d): Outer->test()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/visibility_005.phpt b/tests/classes/inner_classes/visibility_005.phpt
new file mode 100644
index 0000000000000..32737d6cbc5ee
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_005.phpt
@@ -0,0 +1,27 @@
+--TEST--
+accessing outer private methods
+--FILE--
+<?php
+
+class Outer {
+    private function test() {
+        echo __METHOD__ . "\n";
+    }
+    class Middle {
+        private static function test() {
+            echo __METHOD__ . "\n";
+        }
+        class Inner {
+            public function test() {
+                Outer:>Middle::test();
+                $t = new Outer();
+                $t->test();
+            }
+        }
+    }
+}
+new Outer:>Middle:>Inner()->test();
+?>
+--EXPECT--
+Outer:>Middle::test
+Outer::test
diff --git a/tests/classes/inner_classes/visibility_006.phpt b/tests/classes/inner_classes/visibility_006.phpt
new file mode 100644
index 0000000000000..b5f1cc13a8a38
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_006.phpt
@@ -0,0 +1,28 @@
+--TEST--
+scope doesn't bypass scope
+--FILE--
+<?php
+
+class Outer {
+    private function test() {
+        echo __METHOD__ . "\n";
+    }
+    class Middle {
+        private static function test() {
+            echo __METHOD__ . "\n";
+        }
+        class Inner {
+            public function testit() {
+                $this->test();
+            }
+        }
+    }
+}
+new Outer:>Middle:>Inner()->testit();
+?>
+--EXPECTF--
+Fatal error: Uncaught Error: Call to undefined method Outer:>Middle:>Inner::test() in %s:%d
+Stack trace:
+#0 %s(%d): Outer:>Middle:>Inner->testit()
+#1 {main}
+  thrown in %s on line %d
diff --git a/tests/classes/inner_classes/visibility_007.phpt b/tests/classes/inner_classes/visibility_007.phpt
new file mode 100644
index 0000000000000..5ed1ebcae5bca
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_007.phpt
@@ -0,0 +1,27 @@
+--TEST--
+accessing outer protected methods
+--FILE--
+<?php
+
+class Outer {
+    protected function test() {
+        echo __METHOD__ . "\n";
+    }
+    class Middle {
+        protected static function test() {
+            echo __METHOD__ . "\n";
+        }
+        class Inner {
+            public function test() {
+                Outer:>Middle::test();
+                $t = new Outer();
+                $t->test();
+            }
+        }
+    }
+}
+new Outer:>Middle:>Inner()->test();
+?>
+--EXPECT--
+Outer:>Middle::test
+Outer::test
diff --git a/tests/classes/inner_classes/visibility_008.phpt b/tests/classes/inner_classes/visibility_008.phpt
new file mode 100644
index 0000000000000..6a5d8dadf94c5
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_008.phpt
@@ -0,0 +1,30 @@
+--TEST--
+accessing sibling methods
+--FILE--
+<?php
+
+class Outer {
+    protected function test() {
+        echo __METHOD__ . "\n";
+    }
+    protected class Middle {
+        public static function test() {
+            echo __METHOD__ . "\n";
+        }
+    }
+}
+
+class Other extends Outer {
+    class Inner {
+        public function test() {
+            Outer:>Middle::test();
+            $t = new Outer();
+            $t->test();
+        }
+    }
+}
+new Other:>Inner()->test();
+?>
+--EXPECT--
+Outer:>Middle::test
+Outer::test
diff --git a/tests/classes/inner_classes/visibility_009.phpt b/tests/classes/inner_classes/visibility_009.phpt
new file mode 100644
index 0000000000000..4bf9ce96dd250
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_009.phpt
@@ -0,0 +1,38 @@
+--TEST--
+deeply nested property visibility
+--FILE--
+<?php
+
+class Outer {
+    private int $i;
+    private static int $j;
+    class Middle {
+        private int $i;
+        private static int $j;
+        class Inner {
+            public static function test() {
+                var_dump(Outer::$j = 5);
+                var_dump(Outer:>Middle::$j = 42);
+                $foo = new Outer();
+                $foo->i = 42;
+                var_dump($foo);
+                $foo = new Outer:>Middle();
+                $foo->i = 42;
+                var_dump($foo);
+            }
+        }
+    }
+}
+Outer:>Middle:>Inner::test();
+?>
+--EXPECT--
+int(5)
+int(42)
+object(Outer)#1 (1) {
+  ["i":"Outer":private]=>
+  int(42)
+}
+object(Outer:>Middle)#2 (1) {
+  ["i":"Outer:>Middle":private]=>
+  int(42)
+}
diff --git a/tests/classes/inner_classes/visibility_010.phpt b/tests/classes/inner_classes/visibility_010.phpt
new file mode 100644
index 0000000000000..d70478ba09a57
--- /dev/null
+++ b/tests/classes/inner_classes/visibility_010.phpt
@@ -0,0 +1,41 @@
+--TEST--
+constructors
+--FILE--
+<?php
+
+class User {
+    public private(set) string $name;
+    public private(set) string $email;
+
+    private function __construct(self:>Builder $builder) {
+        $this->name = $builder->name;
+        $this->email = $builder->email;
+    }
+
+    public readonly final class Builder {
+        public function __construct(public private(set) string|null $name = null, public private(set) string|null $email = null) {}
+
+        public function withEmail(string $email): self {
+            return new self($this->name, $email);
+        }
+
+        public function withName(string $name): self {
+            return new self($name, $this->email);
+        }
+
+        public function build(): User {
+            return new User($this);
+        }
+    }
+}
+
+$user = new User:>Builder()->withName('Rob')->withEmail('rob@example.com')->build();
+var_dump($user);
+?>
+--EXPECT--
+object(User)#2 (2) {
+  ["name"]=>
+  string(3) "Rob"
+  ["email"]=>
+  string(15) "rob@example.com"
+}