Implement ZEND_ARRAY_KEY_EXISTS opcode to speed up array_key_exists()

diff --git a/NEWS b/NEWS
index e389e629f96d9b88fd3f6c8a6b0d3a5d1766d1fc..b27f23027e9a61f3db365de536f9a77a62a4cdb7 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,10 @@ PHP                                                                        NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
 ?? ??? ????, PHP 7.4.0alpha1
 
+- Core:
+  . Implemented request #76148 (Add array_key_exists() to the list of
+    specially compiled functions). (Majkl578)
+
 - CURL:
   . Fixed bug #76480 (Use curl_multi_wait() so that timeouts are respected).
     (Pierrick)

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 11a5256657c7cd7eec684863a7c24e04871c093f..b6c8176cc4b0bf16af771f85c989db1c406577c9 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -2088,6 +2088,7 @@ ZEND_API int zend_is_smart_branch(zend_op *opline) /* {{{ */
                case ZEND_TYPE_CHECK:
                case ZEND_DEFINED:
                case ZEND_IN_ARRAY:
+               case ZEND_ARRAY_KEY_EXISTS:
                        return 1;
                default:
                        return 0;
@@ -3758,6 +3759,22 @@ int zend_compile_func_get_args(znode *result, zend_ast_list *args) /* {{{ */
 }
 /* }}} */
 
+int zend_compile_func_array_key_exists(znode *result, zend_ast_list *args) /* {{{ */
+{
+       znode subject, needle;
+
+       if (args->children != 2) {
+               return FAILURE;
+       }
+
+       zend_compile_expr(&needle, args->child[0]);
+       zend_compile_expr(&subject, args->child[1]);
+
+       zend_emit_op_tmp(result, ZEND_ARRAY_KEY_EXISTS, &needle, &subject);
+       return SUCCESS;
+}
+/* }}} */
+
 int zend_compile_func_array_slice(znode *result, zend_ast_list *args) /* {{{ */
 {
        if (CG(active_op_array)->function_name
@@ -3869,6 +3886,8 @@ int zend_try_compile_special_func(znode *result, zend_string *lcname, zend_ast_l
                return zend_compile_func_get_args(result, args);
        } else if (zend_string_equals_literal(lcname, "array_slice")) {
                return zend_compile_func_array_slice(result, args);
+       } else if (zend_string_equals_literal(lcname, "array_key_exists")) {
+               return zend_compile_func_array_key_exists(result, args);
        } else {
                return FAILURE;
        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 7b43535dbc2a6b6f7de4cfd81f51c2fcecd65315..bd8b51300f757cf26f159f2268cb325732f8ae34 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -6370,6 +6370,69 @@ ZEND_VM_C_LABEL(isset_object_finish):
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+ZEND_VM_HANDLER(199, ZEND_ARRAY_KEY_EXISTS, CV|TMPVAR|CONST, CV|TMPVAR|CONST)
+{
+       USE_OPLINE
+
+       zend_free_op free_op1, free_op2;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
+       subject = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
+
+ZEND_VM_C_LABEL(try_again_subject):
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               ZEND_VM_C_GOTO(try_again_subject);
+       } else {
+               if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+               FREE_OP2();
+               FREE_OP1();
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+ZEND_VM_C_LABEL(try_again_key):
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               ZEND_VM_C_GOTO(try_again_key);
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       FREE_OP2();
+       FREE_OP1();
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 ZEND_VM_COLD_HANDLER(79, ZEND_EXIT, CONST|TMPVAR|UNUSED|CV, ANY)
 {
        USE_OPLINE

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 5d2a49501ab5e9e20f91c65026b1d9efeddec579..d47413364a8f48ce2a262ce4efba8f000ebb646a 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -5736,6 +5736,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = RT_CONSTANT(opline, opline->op1);
+       subject = RT_CONSTANT(opline, opline->op2);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_class_entry *parent;
@@ -7694,6 +7756,69 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zend_free_op free_op2;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = RT_CONSTANT(opline, opline->op1);
+       subject = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+               zval_ptr_dtor_nogc(free_op2);
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -10762,6 +10887,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = RT_CONSTANT(opline, opline->op1);
+       subject = EX_VAR(opline->op2.var);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -14325,6 +14512,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zend_free_op free_op1;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       subject = RT_CONSTANT(opline, opline->op2);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+               zval_ptr_dtor_nogc(free_op1);
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       zval_ptr_dtor_nogc(free_op1);
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -15786,6 +16035,69 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zend_free_op free_op1, free_op2;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       subject = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+               zval_ptr_dtor_nogc(free_op2);
+               zval_ptr_dtor_nogc(free_op1);
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+       zval_ptr_dtor_nogc(free_op1);
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL zend_fetch_static_prop_helper_SPEC_TMPVAR_VAR(int type ZEND_OPCODE_HANDLER_ARGS_DC)
 {
        USE_OPLINE
@@ -17646,6 +17958,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zend_free_op free_op1;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = _get_zval_ptr_var(opline->op1.var, &free_op1 EXECUTE_DATA_CC);
+       subject = EX_VAR(opline->op2.var);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+               zval_ptr_dtor_nogc(free_op1);
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       zval_ptr_dtor_nogc(free_op1);
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -41222,6 +41596,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = EX_VAR(opline->op1.var);
+       subject = RT_CONSTANT(opline, opline->op2);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -44755,6 +45191,69 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       zend_free_op free_op2;
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = EX_VAR(opline->op1.var);
+       subject = _get_zval_ptr_var(opline->op2.var, &free_op2 EXECUTE_DATA_CC);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+               zval_ptr_dtor_nogc(free_op2);
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+       zval_ptr_dtor_nogc(free_op2);
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -50552,6 +51051,68 @@ isset_object_finish:
        ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+
+       zval *key, *subject;
+       HashTable* ht;
+       int result;
+
+       SAVE_OPLINE();
+
+       key = EX_VAR(opline->op1.var);
+       subject = EX_VAR(opline->op2.var);
+
+try_again_subject:
+       if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) {
+               ht = Z_ARRVAL_P(subject);
+       } else if (UNEXPECTED(Z_TYPE_P(subject) == IS_OBJECT)) {
+               ht = Z_OBJPROP_P(subject);
+       } else if (Z_ISREF_P(subject)) {
+               subject = Z_REFVAL_P(subject);
+               goto try_again_subject;
+       } else {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(subject) == IS_UNDEF)) {
+                       subject = ZVAL_UNDEFINED_OP2();
+               }
+               zend_internal_type_error(EX_USES_STRICT_TYPES(), "array_key_exists() expects parameter 2 to be array, %s given", zend_get_type_by_const(Z_TYPE_P(subject)));
+
+
+               ZVAL_NULL(EX_VAR(opline->result.var));
+               ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+       }
+
+try_again_key:
+       if (EXPECTED(Z_TYPE_P(key) == IS_STRING)) {
+               result = zend_symtable_exists_ind(ht, Z_STR_P(key));
+       } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) {
+               result = zend_hash_index_exists(ht, Z_LVAL_P(key));
+       } else if (UNEXPECTED(Z_TYPE_P(key) == IS_NULL)) {
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_TYPE_P(key) <= IS_NULL) {
+               if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) {
+                       ZVAL_UNDEFINED_OP1();
+               }
+               result = zend_hash_exists_ind(ht, ZSTR_EMPTY_ALLOC());
+       } else if (Z_ISREF_P(key)) {
+               key = Z_REFVAL_P(key);
+               goto try_again_key;
+       } else {
+               zend_error(E_WARNING, "array_key_exists(): The first argument should be either a string or an integer");
+               result = 0;
+       }
+
+
+       ZEND_VM_SMART_BRANCH(result, 1);
+       ZVAL_BOOL(EX_VAR(opline->result.var), result);
+       ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
+}
+
 static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -53749,6 +54310,31 @@ ZEND_API void execute_ex(zend_execute_data *ex)
                        (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL,
+                       (void*)&&ZEND_NULL_LABEL,
+                       (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL,
                        (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
                        (void*)&&ZEND_NULL_LABEL,
@@ -55317,6 +55903,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST):
                                VM_TRACE(ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST)
                                ZEND_DECLARE_INHERITED_CLASS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55517,6 +56107,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMP):
                                VM_TRACE(ZEND_YIELD_SPEC_CONST_TMP)
                                ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -55773,6 +56367,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_YIELD_SPEC_CONST_CV):
                                VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
                                ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56353,6 +56951,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST):
                                VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST)
                                ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56473,6 +57075,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR):
                                VM_TRACE(ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR)
                                ZEND_FETCH_STATIC_PROP_R_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -56657,6 +57263,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_RETURN_SPEC_TMP):
                                VM_TRACE(ZEND_RETURN_SPEC_TMP)
 {
@@ -59135,6 +59745,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_INSTANCEOF_SPEC_CV_CONST):
                                VM_TRACE(ZEND_INSTANCEOF_SPEC_CV_CONST)
                                ZEND_INSTANCEOF_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59503,6 +60117,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP):
                                VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP)
                                ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -60143,6 +60761,10 @@ zend_leave_helper_SPEC_LABEL:
                                VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV)
                                ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
                                HYBRID_BREAK();
+                       HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV):
+                               VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV)
+                               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+                               HYBRID_BREAK();
                        HYBRID_CASE(ZEND_YIELD_SPEC_CV_CV):
                                VM_TRACE(ZEND_YIELD_SPEC_CV_CV)
                                ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -63228,6 +63850,31 @@ void zend_vm_init(void)
                ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER,
+               ZEND_NULL_HANDLER,
+               ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER,
                ZEND_JMP_FORWARD_SPEC_HANDLER,
                ZEND_NULL_HANDLER,
                ZEND_NULL_HANDLER,
@@ -64268,9 +64915,9 @@ void zend_vm_init(void)
                2430,
                2431 | SPEC_RULE_OP1,
                2436,
-               3916,
+               3941,
                2437,
-               3916,
+               3941,
                2438 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA,
                2563 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
                2588,
@@ -64278,8 +64925,8 @@ void zend_vm_init(void)
                2590,
                2591 | SPEC_RULE_OP1,
                2596,
-               3916,
-               3916,
+               3941,
+               3941,
                2597,
                2598,
                2599,
@@ -64323,7 +64970,8 @@ void zend_vm_init(void)
                3015,
                3016 | SPEC_RULE_ISSET,
                3018 | SPEC_RULE_OP2,
-               3916
+               3023 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
+               3941
        };
 #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
        zend_opcode_handler_funcs = labels;
@@ -64526,7 +65174,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 = 3024 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3049 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64534,7 +65182,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 = 3049 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3074 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64542,7 +65190,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 = 3074 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3099 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                                if (op->op1_type < op->op2_type) {
                                        zend_swap_operands(op);
                                }
@@ -64553,17 +65201,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 = 3099 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3124 | 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 = 3124 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3149 | 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 = 3149 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3174 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_MUL:
@@ -64574,17 +65222,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 = 3174 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3199 | 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 = 3199 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3224 | 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 = 3224 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+                               spec = 3249 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_EQUAL:
@@ -64595,12 +65243,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 = 3249 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3274 | 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 = 3324 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3349 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_NOT_EQUAL:
@@ -64611,12 +65259,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 = 3399 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3424 | 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 = 3474 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+                               spec = 3499 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
                        }
                        break;
                case ZEND_IS_SMALLER:
@@ -64624,12 +65272,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 = 3549 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3574 | 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 = 3624 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3649 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_IS_SMALLER_OR_EQUAL:
@@ -64637,75 +65285,75 @@ 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 = 3699 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3724 | 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 = 3774 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+                               spec = 3799 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
                        }
                        break;
                case ZEND_QM_ASSIGN:
                        if (op1_info == MAY_BE_DOUBLE) {
-                               spec = 3867 | SPEC_RULE_OP1;
+                               spec = 3892 | 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 = 3872 | SPEC_RULE_OP1;
+                               spec = 3897 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_PRE_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3849 | SPEC_RULE_RETVAL;
+                               spec = 3874 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3851 | SPEC_RULE_RETVAL;
+                               spec = 3876 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3853 | SPEC_RULE_RETVAL;
+                               spec = 3878 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_PRE_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3855 | SPEC_RULE_RETVAL;
+                               spec = 3880 | SPEC_RULE_RETVAL;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3857 | SPEC_RULE_RETVAL;
+                               spec = 3882 | SPEC_RULE_RETVAL;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3859 | SPEC_RULE_RETVAL;
+                               spec = 3884 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_POST_INC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3861;
+                               spec = 3886;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3862;
+                               spec = 3887;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3863;
+                               spec = 3888;
                        }
                        break;
                case ZEND_POST_DEC:
                        if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-                               spec = 3864;
+                               spec = 3889;
                        } else if (op1_info == MAY_BE_LONG) {
-                               spec = 3865;
+                               spec = 3890;
                        } else if (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)) {
-                               spec = 3866;
+                               spec = 3891;
                        }
                        break;
                case ZEND_JMP:
                        if (OP_JMP_ADDR(op, op->op1) > op) {
-                               spec = 3023;
+                               spec = 3048;
                        }
                        break;
                case ZEND_SEND_VAL:
                        if (op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 3912;
+                               spec = 3937;
                        }
                        break;
                case ZEND_SEND_VAR_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3907 | SPEC_RULE_OP1;
+                               spec = 3932 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_FE_FETCH_R:
                        if (op->op2_type == IS_CV && (op1_info & (MAY_BE_UNDEF|MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
-                               spec = 3914 | SPEC_RULE_RETVAL;
+                               spec = 3939 | SPEC_RULE_RETVAL;
                        }
                        break;
                case ZEND_FETCH_DIM_R:
@@ -64713,17 +65361,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 = 3877 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+                               spec = 3902 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
                        }
                        break;
                case ZEND_SEND_VAL_EX:
                        if (op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-                               spec = 3913;
+                               spec = 3938;
                        }
                        break;
                case ZEND_SEND_VAR:
                        if ((op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-                               spec = 3902 | SPEC_RULE_OP1;
+                               spec = 3927 | SPEC_RULE_OP1;
                        }
                        break;
                case ZEND_BW_OR:

diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index c5ead7e1e418a706e18821f17f255b47c647ec86..65342d343bc89c82107d494fbc02efe9984932b4 100644 (file)
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1561,495 +1561,511 @@
        _(3019, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
        _(3020, ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) \
        _(3022, ZEND_FETCH_LIST_W_SPEC_VAR_CV) \
-       _(3023, ZEND_JMP_FORWARD_SPEC) \
-       _(3029, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3030, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3031, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3033, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3034, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3035, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3036, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3038, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3044, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3045, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3046, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3048, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3054, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3055, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3056, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3058, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3059, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3060, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3061, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3063, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3069, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-       _(3070, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3071, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3073, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3079, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3080, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3081, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3083, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3084, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3085, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3086, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3088, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3094, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3095, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3096, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3098, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3100, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3101, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3103, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-       _(3104, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3105, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3106, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3108, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3109, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3110, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3111, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3113, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3119, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3120, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3121, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3123, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3125, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3126, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3128, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-       _(3129, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3130, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3131, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3133, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3134, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3135, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3136, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3138, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3144, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-       _(3145, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3146, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3148, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3150, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3151, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3153, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3154, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3155, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3156, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3158, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3159, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3160, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3161, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3163, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3169, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3170, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3171, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3173, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3179, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3180, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3181, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3183, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3184, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3185, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3186, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3188, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3194, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-       _(3195, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3196, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3198, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-       _(3204, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3205, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3206, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3208, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3209, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3210, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3211, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3213, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3219, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3220, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3221, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3223, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3229, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3230, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3231, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3233, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3234, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3235, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3236, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3238, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3244, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3245, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3246, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3248, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3264, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3265, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3266, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3267, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3268, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3269, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3270, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3271, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3272, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3276, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3277, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3278, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3279, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3280, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3281, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3282, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3283, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3284, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3285, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3286, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3287, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3292, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3309, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3310, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3313, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3314, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3315, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3321, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3322, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3323, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3339, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3340, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3341, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3342, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3343, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3344, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3345, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3346, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3347, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3351, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3352, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3353, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3354, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3355, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3356, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3357, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3358, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3359, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3360, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3361, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3362, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3367, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3384, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3385, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3388, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3389, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3390, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3396, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3397, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3398, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3414, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3415, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3416, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3417, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3418, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3419, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3420, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3421, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3422, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3426, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3427, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3428, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3429, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3430, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3431, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3432, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3433, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3434, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3435, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3436, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3437, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3442, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3459, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3460, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3463, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3464, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3465, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3471, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3472, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3473, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3489, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3490, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3491, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3492, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3493, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3494, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3495, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3496, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3497, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3501, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3502, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3503, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3504, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3505, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3506, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3507, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3508, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3509, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3510, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3511, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3512, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3517, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3534, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3535, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3538, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3539, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3540, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3546, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3547, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3548, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3552, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3553, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3554, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3555, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3556, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3557, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3561, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-       _(3562, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3563, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3564, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3565, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3566, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3567, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3568, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3569, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3570, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3571, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3572, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3576, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3577, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3578, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3579, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3580, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3581, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3582, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3583, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3584, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3585, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3586, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3587, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3592, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3609, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-       _(3610, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3613, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3614, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3615, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3621, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3622, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3623, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3627, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3628, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3629, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3630, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3631, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3632, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3636, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3637, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3638, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3639, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3640, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3641, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3642, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3643, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3644, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3645, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3646, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3647, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3651, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3652, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3658, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3659, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3660, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3667, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3684, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3685, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3688, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3689, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3690, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3696, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3697, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3698, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3702, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3703, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3704, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3705, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3706, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3707, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3711, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-       _(3712, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3713, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3714, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3715, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3716, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3717, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3718, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3719, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3720, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3721, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3722, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3726, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3727, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3733, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3734, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3735, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3742, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3759, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-       _(3760, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3763, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3764, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3765, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3771, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-       _(3772, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3773, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3777, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3778, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3779, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3780, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3781, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3782, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3786, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-       _(3787, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-       _(3788, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-       _(3789, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3790, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3791, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3792, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3793, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3794, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3795, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3796, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3797, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3801, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3802, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3808, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3809, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3810, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3817, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3834, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-       _(3835, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-       _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-       _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3838, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3839, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3840, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3846, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-       _(3847, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-       _(3848, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-       _(3849, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3850, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3851, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3852, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3853, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3854, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3855, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3856, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3857, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3858, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3859, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
-       _(3860, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
-       _(3861, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3862, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
-       _(3863, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3864, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
-       _(3865, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
-       _(3866, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
-       _(3867, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-       _(3868, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3869, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3871, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-       _(3872, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-       _(3873, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3874, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3876, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-       _(3878, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3879, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3881, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-       _(3882, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3883, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3884, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3886, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3887, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-       _(3888, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3889, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3891, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-       _(3897, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-       _(3898, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3899, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3901, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-       _(3904, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-       _(3906, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-       _(3909, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
-       _(3911, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
-       _(3912, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-       _(3913, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-       _(3914, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-       _(3915, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-       _(3915+1, ZEND_NULL)
+       _(3023, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST) \
+       _(3024, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+       _(3025, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) \
+       _(3027, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV) \
+       _(3028, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+       _(3029, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3030, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3032, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+       _(3033, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) \
+       _(3034, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3035, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) \
+       _(3037, ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) \
+       _(3043, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST) \
+       _(3044, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+       _(3045, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) \
+       _(3047, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV) \
+       _(3048, ZEND_JMP_FORWARD_SPEC) \
+       _(3054, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3055, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3056, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3058, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3059, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3060, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3061, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3063, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3069, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3070, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3071, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3073, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3079, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3080, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3081, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3083, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3084, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3085, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3086, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3088, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3094, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
+       _(3095, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3096, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3098, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3104, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3105, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3106, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3108, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3109, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3110, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3111, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3113, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3119, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3120, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3121, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3123, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3125, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3126, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3128, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+       _(3129, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3130, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3131, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3133, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3134, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3135, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3136, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3138, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3144, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3145, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3146, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3148, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3150, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3151, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3153, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+       _(3154, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3155, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3156, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3158, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3159, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3160, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3161, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3163, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3169, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
+       _(3170, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3171, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3173, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3175, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3176, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3178, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3179, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3180, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3181, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3183, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3184, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3185, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3186, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3188, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3194, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3195, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3196, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3198, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3204, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3205, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3206, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3208, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3209, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3210, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3211, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3213, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3219, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
+       _(3220, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3221, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3223, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+       _(3229, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3230, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3231, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3233, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3234, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3235, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3236, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3238, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3244, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3245, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3246, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3248, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3254, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3255, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3256, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3258, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3259, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3260, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3261, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3263, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3269, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3270, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3271, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3273, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3289, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3290, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3291, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3292, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3293, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3294, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3295, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3296, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3297, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3301, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3302, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3303, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3304, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3305, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3306, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3307, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3308, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3309, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3310, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3311, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3312, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3316, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3317, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3318, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3334, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3335, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3336, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3337, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3338, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3339, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3340, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3341, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3342, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3346, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3347, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3348, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3364, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3365, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3366, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3367, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3368, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3369, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3370, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3371, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3372, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3376, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3377, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3378, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3379, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3380, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3381, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3382, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3383, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3384, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3385, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3386, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3387, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3391, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3392, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3393, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3409, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3410, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3411, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3412, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3413, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3414, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3415, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3416, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3417, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3421, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3422, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3423, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3439, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3440, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3441, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3442, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3443, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3444, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3445, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3446, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3447, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3451, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3452, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3453, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3454, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3455, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3456, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3457, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3458, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3459, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3460, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3461, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3462, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3466, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3467, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3468, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3484, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3485, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3486, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3487, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3488, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3489, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3490, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3491, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3492, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3496, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3497, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3498, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3514, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3515, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3516, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3517, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3518, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3519, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3520, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3521, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3522, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3526, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3527, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3528, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3529, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3530, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3531, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3532, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3533, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3534, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3535, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3536, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3537, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3541, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3542, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3543, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3559, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3560, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3561, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3562, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3563, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3564, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3565, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3566, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3567, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3571, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3572, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3573, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3577, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3578, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3579, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3580, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3581, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3582, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3586, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+       _(3587, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3588, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3589, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3590, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3591, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3592, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3593, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3594, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3595, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3596, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3597, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3601, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3602, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3603, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3604, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3605, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3606, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3607, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3608, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3609, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3610, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3611, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3612, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3616, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3617, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3618, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3634, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+       _(3635, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3636, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3637, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3638, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3639, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3640, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3641, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3642, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3646, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3647, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3648, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3652, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3653, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3654, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3655, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3656, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3657, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3661, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3662, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3663, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3664, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3665, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3666, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3667, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3668, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3669, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3670, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3671, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3672, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3676, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3677, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3678, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3679, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3680, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3681, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3682, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3683, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3684, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3685, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3686, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3687, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3691, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3692, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3693, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3709, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3710, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3711, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3712, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3713, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3714, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3715, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3716, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3717, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3721, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3722, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3723, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3727, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3728, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3729, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3730, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3731, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3732, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3736, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+       _(3737, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3738, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3739, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3740, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3741, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3742, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3743, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3744, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3745, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3746, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3747, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3751, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3752, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3753, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3754, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3755, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3756, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3757, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3758, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3759, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3760, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3761, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3762, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3766, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3767, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3768, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3784, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+       _(3785, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3786, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3787, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3788, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3789, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3790, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3791, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3792, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3796, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+       _(3797, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3798, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3802, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3803, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3804, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3805, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3806, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3807, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3811, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+       _(3812, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+       _(3813, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+       _(3814, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3815, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3816, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3817, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3818, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3819, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3820, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3821, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3822, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3826, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3827, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3828, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3829, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3830, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3831, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3832, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3833, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3834, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3835, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3836, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3837, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3841, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3842, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3843, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3859, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+       _(3860, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+       _(3861, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+       _(3862, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3863, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3864, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3865, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3866, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3867, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3871, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+       _(3872, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+       _(3873, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+       _(3874, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3875, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3876, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3877, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3878, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3879, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3880, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3881, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3882, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3883, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3884, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+       _(3885, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+       _(3886, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(3887, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+       _(3888, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(3889, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+       _(3890, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+       _(3891, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+       _(3892, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
+       _(3893, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3894, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3896, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+       _(3897, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
+       _(3898, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(3899, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(3901, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+       _(3903, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(3904, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(3906, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+       _(3907, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(3908, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3909, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3911, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3912, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
+       _(3913, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3914, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3916, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+       _(3922, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
+       _(3923, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(3924, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(3926, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+       _(3929, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+       _(3931, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+       _(3934, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR) \
+       _(3936, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV) \
+       _(3937, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+       _(3938, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+       _(3939, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+       _(3940, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+       _(3940+1, ZEND_NULL)

diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 663e5ba038f1e6fb31727f88def4695676beabc9..12d8fa8d679b8092582b26fcc4b5f64a338b9fb4 100644 (file)
--- 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[199] = {
+static const char *zend_vm_opcodes_names[200] = {
        "ZEND_NOP",
        "ZEND_ADD",
        "ZEND_SUB",
@@ -222,9 +222,10 @@ static const char *zend_vm_opcodes_names[199] = {
        "ZEND_UNSET_CV",
        "ZEND_ISSET_ISEMPTY_CV",
        "ZEND_FETCH_LIST_W",
+       "ZEND_ARRAY_KEY_EXISTS",
 };
 
-static uint32_t zend_vm_opcodes_flags[199] = {
+static uint32_t zend_vm_opcodes_flags[200] = {
        0x00000000,
        0x00000707,
        0x00000707,
@@ -424,6 +425,7 @@ static uint32_t zend_vm_opcodes_flags[199] = {
        0x00000101,
        0x00020101,
        0x00000701,
+       0x00000707,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(zend_uchar opcode) {

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 35938069b7f23e71a52e0f5e966e8120c711bb28..922377b72b564957e59e87984dfd3caa9a605dcd 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -269,7 +269,8 @@ END_EXTERN_C()
 #define ZEND_UNSET_CV                        196
 #define ZEND_ISSET_ISEMPTY_CV                197
 #define ZEND_FETCH_LIST_W                    198
+#define ZEND_ARRAY_KEY_EXISTS                199
 
-#define ZEND_VM_LAST_OPCODE                  198
+#define ZEND_VM_LAST_OPCODE                  199
 
 #endif

diff --git a/ext/opcache/Optimizer/zend_inference.c b/ext/opcache/Optimizer/zend_inference.c
index 584f05c56e667e8cfa43da16c54bcd6052f3a732..9f1dfdba201f52ef3c5a597ccdfea7e2d9bb9216 100644 (file)
--- a/ext/opcache/Optimizer/zend_inference.c
+++ b/ext/opcache/Optimizer/zend_inference.c
@@ -2376,6 +2376,13 @@ static int zend_update_type_info(const zend_op_array *op_array,
                case ZEND_IN_ARRAY:
                        UPDATE_SSA_TYPE(MAY_BE_FALSE|MAY_BE_TRUE, ssa_ops[i].result_def);
                        break;
+               case ZEND_ARRAY_KEY_EXISTS:
+                       tmp = MAY_BE_FALSE|MAY_BE_TRUE;
+                       if (t2 & ((MAY_BE_ANY|MAY_BE_UNDEF) - (MAY_BE_ARRAY|MAY_BE_OBJECT))) {
+                               tmp |= MAY_BE_NULL;
+                       }
+                       UPDATE_SSA_TYPE(tmp, ssa_ops[i].result_def);
+                       break;
                case ZEND_CAST:
                        if (ssa_ops[i].op1_def >= 0) {
                                tmp = t1;