Optimized access to static properties using executor specialization. A constant class...

diff --git a/NEWS b/NEWS
index ae305a84b5ec056aae967968b6dbbfa2b9ce51ce..344be69361b6566d721a6ebf200576fc0d3f290c 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -12,6 +12,9 @@
     ZEND_RETURN_BY_REF
   . optimized access to global constants using values with pre-calculated
     hash_values from litersls table
+  . optimized access to static properties using executor specialization.
+    A constant class name may be used as a direct operand of ZEND_FETCH_*
+    instruction without previous ZEND_FETCH_CLASS.
 - Added concept of interned strings. All strings constants known at compile
   time are allocated in a single copy and never changed. (Dmitry)
 - Added an optimization which saves memory and emalloc/efree calls for empty

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 336b0d9c4d922158e93284fb819200d279a6d4c5..81e1f27a2ddc7509c32fdc80595e8412498b99c7 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -360,6 +360,7 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv) /* {{{ */
        CONSTANT_EX(op_array, i) = *zv;
        Z_SET_REFCOUNT(CONSTANT_EX(op_array, i), 2);
        Z_SET_ISREF(CONSTANT_EX(op_array, i));
+       op_array->literals[i].hash_value = 0;
        return i;
 }
 /* }}} */
@@ -690,7 +691,15 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
        zend_op *opline_ptr;
        zend_op opline;
 
-       zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
+       if (class_name->op_type == IS_CONST &&
+           ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) {
+               ulong fetch_type = ZEND_FETCH_CLASS_GLOBAL;
+
+               zend_resolve_class_name(class_name, &fetch_type, 1 TSRMLS_CC);
+               class_node = *class_name;
+       } else {
+               zend_do_fetch_class(&class_node, class_name TSRMLS_CC);
+       }
        zend_stack_top(&CG(bp_stack), (void **) &fetch_list_ptr);
        if (result->op_type == IS_CV) {
                init_op(&opline TSRMLS_CC);
@@ -701,8 +710,13 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
                opline.op1_type = IS_CONST;
                LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0);
                CALCULATE_LITERAL_HASH(opline.op1.constant);
-               SET_UNUSED(opline.op2);
-               SET_NODE(opline.op2, &class_node);
+               if (class_node.op_type == IS_CONST) {
+                       opline.op2_type = IS_CONST;
+                       opline.op2.constant =
+                               zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
+               } else {
+                       SET_NODE(opline.op2, &class_node);
+               }
                GET_NODE(result,opline.result);
                opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
                opline_ptr = &opline;
@@ -720,14 +734,25 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
                        opline.op1_type = IS_CONST;
                        LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[opline_ptr->op1.var].name), CG(active_op_array)->vars[opline_ptr->op1.var].name_len, 0);
                        CALCULATE_LITERAL_HASH(opline.op1.constant);
-                       SET_UNUSED(opline.op2);
-                       SET_NODE(opline.op2, &class_node);
+                       if (class_node.op_type == IS_CONST) {
+                               opline.op2_type = IS_CONST;
+                               opline.op2.constant =
+                                       zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
+                       } else {
+                               SET_NODE(opline.op2, &class_node);
+                       }
                        opline.extended_value |= ZEND_FETCH_STATIC_MEMBER;
                        COPY_NODE(opline_ptr->op1, opline.result);
 
                        zend_llist_prepend_element(fetch_list_ptr, &opline);
                } else {
-                       SET_NODE(opline_ptr->op2, &class_node);
+                       if (class_node.op_type == IS_CONST) {
+                               opline_ptr->op2_type = IS_CONST;
+                               opline_ptr->op2.constant =
+                                       zend_add_class_name_literal(CG(active_op_array), &class_node.u.constant TSRMLS_CC);
+                       } else {
+                               SET_NODE(opline.op2, &class_node);
+                       }
                        opline_ptr->extended_value |= ZEND_FETCH_STATIC_MEMBER;
                }
        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index f4129c1aecbd231c888474ad3eef48bfeca38db2..c3ae638dcc2c7461219044b18c736113006fb06f 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1011,7 +1011,7 @@ ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
        ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
 }
 
-ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type)
+ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|VAR, int type)
 {
        USE_OPLINE
        zend_free_op free_op1;
@@ -1031,8 +1031,15 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type
                varname = &tmp_varname;
        }
 
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               retval = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       if (OP2_TYPE != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (OP2_TYPE == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
                FREE_OP1();
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -1123,22 +1130,22 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, ANY, int type
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
 }
 
-ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
 }
 
-ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_RW);
 }
 
-ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        USE_OPLINE
 
@@ -1146,12 +1153,12 @@ ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, ANY)
                ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R);
 }
 
-ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_UNSET);
 }
 
-ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(89, ZEND_FETCH_IS, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_IS);
 }
@@ -3692,7 +3699,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        USE_OPLINE
        zval tmp, *varname;
@@ -3725,8 +3732,15 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, ANY)
                Z_ADDREF_P(varname);
        }
 
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               zend_std_unset_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       if (OP2_TYPE != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (OP2_TYPE == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
        } else {
                ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
 
@@ -4187,7 +4201,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
+ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
        USE_OPLINE
        zval **value;
@@ -4218,8 +4232,15 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
                        varname = &tmp;
                }
 
-               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-                       value = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               if (OP2_TYPE != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (OP2_TYPE == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 16b76fe0a41b551787ed40af4e70b69937d83f77..b55bf7412a1cb3a6fe2a81285fed6f51c0d1280b 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1475,150 +1475,6 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval **retval;
-       zval tmp_varname;
-       HashTable *target_symbol_table;
-       ulong hash_value;
-
-       SAVE_OPLINE();
-       varname = opline->op1.zv;
-
-       if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-               ZVAL_COPY_VALUE(&tmp_varname, varname);
-               zval_copy_ctor(&tmp_varname);
-               convert_to_string(&tmp_varname);
-               varname = &tmp_varname;
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               retval = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-
-       } else {
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-               if (!target_symbol_table) {
-                       CHECK_EXCEPTION();
-                       ZEND_VM_NEXT_OPCODE();
-               }
-*/
-               if (IS_CONST == IS_CONST) {
-                       hash_value = Z_HASH_P(varname);
-               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
-                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
-               } else {
-                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
-               }
-
-               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
-                       switch (type) {
-                               case BP_VAR_R:
-                               case BP_VAR_UNSET:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_IS:
-                                       retval = &EG(uninitialized_zval_ptr);
-                                       break;
-                               case BP_VAR_RW:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_W:
-                                       Z_ADDREF_P(&EG(uninitialized_zval));
-                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
-                                       break;
-                               EMPTY_SWITCH_DEFAULT_CASE()
-                       }
-               }
-               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-                       case ZEND_FETCH_GLOBAL:
-                               if (IS_CONST != IS_TMP_VAR) {
-
-                               }
-                               break;
-                       case ZEND_FETCH_LOCAL:
-
-                               break;
-                       case ZEND_FETCH_STATIC:
-                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
-                               break;
-                       case ZEND_FETCH_GLOBAL_LOCK:
-                               if (IS_CONST == IS_VAR && !free_op1.var) {
-                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-                               }
-                               break;
-               }
-       }
-
-
-       if (IS_CONST != IS_CONST && varname == &tmp_varname) {
-               zval_dtor(&tmp_varname);
-       }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
-
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
-                       }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
-               }
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       return zend_fetch_var_address_helper_SPEC_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -2225,58 +2081,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval tmp, *varname;
-       HashTable *target_symbol_table;
-
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-                       EX_CV(opline->op1.var) = NULL;
-               } else if (EX_CV(opline->op1.var)) {
-                       zval_ptr_dtor(EX_CV(opline->op1.var));
-                       EX_CV(opline->op1.var) = NULL;
-               }
-               CHECK_EXCEPTION();
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       varname = opline->op1.zv;
-
-       if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-               ZVAL_COPY_VALUE(&tmp, varname);
-               zval_copy_ctor(&tmp);
-               convert_to_string(&tmp);
-               varname = &tmp;
-       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-               Z_ADDREF_P(varname);
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               zend_std_unset_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-       } else {
-               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
-       }
-
-       if (IS_CONST != IS_CONST && varname == &tmp) {
-               zval_dtor(&tmp);
-       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-               zval_ptr_dtor(&varname);
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -2438,73 +2242,6 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        }
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval **value;
-       zend_bool isset = 1;
-
-       SAVE_OPLINE();
-       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EX_CV(opline->op1.var)) {
-                       value = EX_CV(opline->op1.var);
-               } else if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               } else {
-                       isset = 0;
-               }
-       } else {
-               HashTable *target_symbol_table;
-
-               zval tmp, *varname = opline->op1.zv;
-
-               if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_COPY_VALUE(&tmp, varname);
-                       zval_copy_ctor(&tmp);
-                       convert_to_string(&tmp);
-                       varname = &tmp;
-               }
-
-               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-                       value = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-                       if (!value) {
-                               isset = 0;
-                       }
-               } else {
-                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               }
-
-               if (IS_CONST != IS_CONST && varname == &tmp) {
-                       zval_dtor(&tmp);
-               }
-
-       }
-
-       if (opline->extended_value & ZEND_ISSET) {
-               if (isset && Z_TYPE_PP(value) != IS_NULL) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-               if (!isset || !i_zend_is_true(*value)) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 #if 0 || (IS_CONST != IS_UNUSED)
@@ -2848,6 +2585,157 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CONST == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CONST != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CONST == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -3170,6 +3058,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CONST != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = opline->op1.zv;
+
+               if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_CONST != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_CONST == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CONST != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -4001,6 +4022,157 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CONST == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CONST != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CONST == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -4232,6 +4404,290 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CONST != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = opline->op1.zv;
+
+               if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_VAR != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_VAR == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CONST != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CONST == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CONST != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CONST == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -4429,6 +4885,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = opline->op1.zv;
+
+       if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CONST != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CONST == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = opline->op1.zv;
+
+               if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_UNUSED != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_UNUSED == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CONST != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -5063,150 +5652,6 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP(int type, ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval **retval;
-       zval tmp_varname;
-       HashTable *target_symbol_table;
-       ulong hash_value;
-
-       SAVE_OPLINE();
-       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-       if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-               ZVAL_COPY_VALUE(&tmp_varname, varname);
-               zval_copy_ctor(&tmp_varname);
-               convert_to_string(&tmp_varname);
-               varname = &tmp_varname;
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               retval = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-               zval_dtor(free_op1.var);
-       } else {
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-               if (!target_symbol_table) {
-                       CHECK_EXCEPTION();
-                       ZEND_VM_NEXT_OPCODE();
-               }
-*/
-               if (IS_TMP_VAR == IS_CONST) {
-                       hash_value = Z_HASH_P(varname);
-               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
-                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
-               } else {
-                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
-               }
-
-               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
-                       switch (type) {
-                               case BP_VAR_R:
-                               case BP_VAR_UNSET:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_IS:
-                                       retval = &EG(uninitialized_zval_ptr);
-                                       break;
-                               case BP_VAR_RW:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_W:
-                                       Z_ADDREF_P(&EG(uninitialized_zval));
-                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
-                                       break;
-                               EMPTY_SWITCH_DEFAULT_CASE()
-                       }
-               }
-               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-                       case ZEND_FETCH_GLOBAL:
-                               if (IS_TMP_VAR != IS_TMP_VAR) {
-                                       zval_dtor(free_op1.var);
-                               }
-                               break;
-                       case ZEND_FETCH_LOCAL:
-                               zval_dtor(free_op1.var);
-                               break;
-                       case ZEND_FETCH_STATIC:
-                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
-                               break;
-                       case ZEND_FETCH_GLOBAL_LOCK:
-                               if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
-                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-                               }
-                               break;
-               }
-       }
-
-
-       if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
-               zval_dtor(&tmp_varname);
-       }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
-
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
-                       }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
-               }
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       return zend_fetch_var_address_helper_SPEC_TMP(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_TMP(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -5807,58 +6252,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval tmp, *varname;
-       HashTable *target_symbol_table;
-       zend_free_op free_op1;
-
-       SAVE_OPLINE();
-       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-                       EX_CV(opline->op1.var) = NULL;
-               } else if (EX_CV(opline->op1.var)) {
-                       zval_ptr_dtor(EX_CV(opline->op1.var));
-                       EX_CV(opline->op1.var) = NULL;
-               }
-               CHECK_EXCEPTION();
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-       if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-               ZVAL_COPY_VALUE(&tmp, varname);
-               zval_copy_ctor(&tmp);
-               convert_to_string(&tmp);
-               varname = &tmp;
-       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-               Z_ADDREF_P(varname);
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               zend_std_unset_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-       } else {
-               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
-       }
-
-       if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
-               zval_dtor(&tmp);
-       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-               zval_ptr_dtor(&varname);
-       }
-       zval_dtor(free_op1.var);
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -6020,73 +6413,6 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        }
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval **value;
-       zend_bool isset = 1;
-
-       SAVE_OPLINE();
-       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EX_CV(opline->op1.var)) {
-                       value = EX_CV(opline->op1.var);
-               } else if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               } else {
-                       isset = 0;
-               }
-       } else {
-               HashTable *target_symbol_table;
-               zend_free_op free_op1;
-               zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-               if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_COPY_VALUE(&tmp, varname);
-                       zval_copy_ctor(&tmp);
-                       convert_to_string(&tmp);
-                       varname = &tmp;
-               }
-
-               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-                       value = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-                       if (!value) {
-                               isset = 0;
-                       }
-               } else {
-                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               }
-
-               if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
-                       zval_dtor(&tmp);
-               }
-               zval_dtor(free_op1.var);
-       }
-
-       if (opline->extended_value & ZEND_ISSET) {
-               if (isset && Z_TYPE_PP(value) != IS_NULL) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-               if (!isset || !i_zend_is_true(*value)) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 #if 0 || (IS_TMP_VAR != IS_UNUSED)
@@ -6472,6 +6798,157 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zval_dtor(free_op1.var);
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_TMP_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_TMP_VAR != IS_TMP_VAR) {
+                                       zval_dtor(free_op1.var);
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               zval_dtor(free_op1.var);
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -6734,6 +7211,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       zval_dtor(free_op1.var);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_CONST != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_CONST == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               zval_dtor(free_op1.var);
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -7531,6 +8141,157 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zval_dtor(free_op1.var);
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_TMP_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_TMP_VAR != IS_TMP_VAR) {
+                                       zval_dtor(free_op1.var);
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               zval_dtor(free_op1.var);
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -7768,6 +8529,290 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       zval_dtor(free_op1.var);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_VAR != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_VAR == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               zval_dtor(free_op1.var);
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zval_dtor(free_op1.var);
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_TMP_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_TMP_VAR != IS_TMP_VAR) {
+                                       zval_dtor(free_op1.var);
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               zval_dtor(free_op1.var);
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -7866,6 +8911,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HA
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       zval_dtor(free_op1.var);
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_TMP_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_UNUSED != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_UNUSED == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               zval_dtor(free_op1.var);
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -8623,150 +9801,6 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval **retval;
-       zval tmp_varname;
-       HashTable *target_symbol_table;
-       ulong hash_value;
-
-       SAVE_OPLINE();
-       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-       if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-               ZVAL_COPY_VALUE(&tmp_varname, varname);
-               zval_copy_ctor(&tmp_varname);
-               convert_to_string(&tmp_varname);
-               varname = &tmp_varname;
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               retval = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-       } else {
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-               if (!target_symbol_table) {
-                       CHECK_EXCEPTION();
-                       ZEND_VM_NEXT_OPCODE();
-               }
-*/
-               if (IS_VAR == IS_CONST) {
-                       hash_value = Z_HASH_P(varname);
-               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
-                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
-               } else {
-                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
-               }
-
-               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
-                       switch (type) {
-                               case BP_VAR_R:
-                               case BP_VAR_UNSET:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_IS:
-                                       retval = &EG(uninitialized_zval_ptr);
-                                       break;
-                               case BP_VAR_RW:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_W:
-                                       Z_ADDREF_P(&EG(uninitialized_zval));
-                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
-                                       break;
-                               EMPTY_SWITCH_DEFAULT_CASE()
-                       }
-               }
-               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-                       case ZEND_FETCH_GLOBAL:
-                               if (IS_VAR != IS_TMP_VAR) {
-                                       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-                               }
-                               break;
-                       case ZEND_FETCH_LOCAL:
-                               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-                               break;
-                       case ZEND_FETCH_STATIC:
-                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
-                               break;
-                       case ZEND_FETCH_GLOBAL_LOCK:
-                               if (IS_VAR == IS_VAR && !free_op1.var) {
-                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-                               }
-                               break;
-               }
-       }
-
-
-       if (IS_VAR != IS_CONST && varname == &tmp_varname) {
-               zval_dtor(&tmp_varname);
-       }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
-
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
-                       }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
-               }
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       return zend_fetch_var_address_helper_SPEC_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -9488,58 +10522,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval tmp, *varname;
-       HashTable *target_symbol_table;
-       zend_free_op free_op1;
-
-       SAVE_OPLINE();
-       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-                       EX_CV(opline->op1.var) = NULL;
-               } else if (EX_CV(opline->op1.var)) {
-                       zval_ptr_dtor(EX_CV(opline->op1.var));
-                       EX_CV(opline->op1.var) = NULL;
-               }
-               CHECK_EXCEPTION();
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-       if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-               ZVAL_COPY_VALUE(&tmp, varname);
-               zval_copy_ctor(&tmp);
-               convert_to_string(&tmp);
-               varname = &tmp;
-       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-               Z_ADDREF_P(varname);
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               zend_std_unset_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-       } else {
-               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
-       }
-
-       if (IS_VAR != IS_CONST && varname == &tmp) {
-               zval_dtor(&tmp);
-       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-               zval_ptr_dtor(&varname);
-       }
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -9847,73 +10829,6 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval **value;
-       zend_bool isset = 1;
-
-       SAVE_OPLINE();
-       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EX_CV(opline->op1.var)) {
-                       value = EX_CV(opline->op1.var);
-               } else if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               } else {
-                       isset = 0;
-               }
-       } else {
-               HashTable *target_symbol_table;
-               zend_free_op free_op1;
-               zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
-
-               if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_COPY_VALUE(&tmp, varname);
-                       zval_copy_ctor(&tmp);
-                       convert_to_string(&tmp);
-                       varname = &tmp;
-               }
-
-               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-                       value = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-                       if (!value) {
-                               isset = 0;
-                       }
-               } else {
-                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               }
-
-               if (IS_VAR != IS_CONST && varname == &tmp) {
-                       zval_dtor(&tmp);
-               }
-               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-       }
-
-       if (opline->extended_value & ZEND_ISSET) {
-               if (isset && Z_TYPE_PP(value) != IS_NULL) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-               if (!isset || !i_zend_is_true(*value)) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 #if 0 || (IS_VAR != IS_UNUSED)
@@ -10741,6 +11656,157 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        return zend_post_incdec_property_helper_SPEC_VAR_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_VAR != IS_TMP_VAR) {
+                                       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11698,6 +12764,65 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -11834,6 +12959,80 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_CONST != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_CONST == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -14652,6 +15851,157 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
        return zend_post_incdec_property_helper_SPEC_VAR_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_VAR != IS_TMP_VAR) {
+                                       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -15601,6 +16951,65 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -15737,6 +17146,80 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_VAR != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_VAR == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -16144,6 +17627,157 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE
        return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_VAR == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_VAR != IS_TMP_VAR) {
+                                       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+                               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_VAR == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -16508,6 +18142,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+       zend_free_op free_op1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+       if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_VAR != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_VAR == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+               zend_free_op free_op1;
+               zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
+               if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_UNUSED != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_UNUSED == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_VAR != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -23768,150 +25535,6 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV(int type, ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zend_free_op free_op1;
-       zval *varname;
-       zval **retval;
-       zval tmp_varname;
-       HashTable *target_symbol_table;
-       ulong hash_value;
-
-       SAVE_OPLINE();
-       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-
-       if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-               ZVAL_COPY_VALUE(&tmp_varname, varname);
-               zval_copy_ctor(&tmp_varname);
-               convert_to_string(&tmp_varname);
-               varname = &tmp_varname;
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               retval = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-
-       } else {
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-               if (!target_symbol_table) {
-                       CHECK_EXCEPTION();
-                       ZEND_VM_NEXT_OPCODE();
-               }
-*/
-               if (IS_CV == IS_CONST) {
-                       hash_value = Z_HASH_P(varname);
-               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
-                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
-               } else {
-                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
-               }
-
-               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
-                       switch (type) {
-                               case BP_VAR_R:
-                               case BP_VAR_UNSET:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_IS:
-                                       retval = &EG(uninitialized_zval_ptr);
-                                       break;
-                               case BP_VAR_RW:
-                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
-                                       /* break missing intentionally */
-                               case BP_VAR_W:
-                                       Z_ADDREF_P(&EG(uninitialized_zval));
-                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
-                                       break;
-                               EMPTY_SWITCH_DEFAULT_CASE()
-                       }
-               }
-               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-                       case ZEND_FETCH_GLOBAL:
-                               if (IS_CV != IS_TMP_VAR) {
-
-                               }
-                               break;
-                       case ZEND_FETCH_LOCAL:
-
-                               break;
-                       case ZEND_FETCH_STATIC:
-                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
-                               break;
-                       case ZEND_FETCH_GLOBAL_LOCK:
-                               if (IS_CV == IS_VAR && !free_op1.var) {
-                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-                               }
-                               break;
-               }
-       }
-
-
-       if (IS_CV != IS_CONST && varname == &tmp_varname) {
-               zval_dtor(&tmp_varname);
-       }
-       if (RETURN_VALUE_USED(opline)) {
-               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-               }
-               PZVAL_LOCK(*retval);
-               switch (type) {
-                       case BP_VAR_R:
-                       case BP_VAR_IS:
-                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
-                               break;
-                       case BP_VAR_UNSET: {
-                               zend_free_op free_res;
-
-                               PZVAL_UNLOCK(*retval, &free_res);
-                               if (retval != &EG(uninitialized_zval_ptr)) {
-                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
-                               }
-                               PZVAL_LOCK(*retval);
-                               FREE_OP_VAR_PTR(free_res);
-                       }
-                       /* break missing intentionally */
-                       default:
-                               EX_T(opline->result.var).var.ptr_ptr = retval;
-                               break;
-               }
-       }
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-
-       return zend_fetch_var_address_helper_SPEC_CV(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
-static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return zend_fetch_var_address_helper_SPEC_CV(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -24620,58 +26243,6 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval tmp, *varname;
-       HashTable *target_symbol_table;
-
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-                       EX_CV(opline->op1.var) = NULL;
-               } else if (EX_CV(opline->op1.var)) {
-                       zval_ptr_dtor(EX_CV(opline->op1.var));
-                       EX_CV(opline->op1.var) = NULL;
-               }
-               CHECK_EXCEPTION();
-               ZEND_VM_NEXT_OPCODE();
-       }
-
-       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
-
-       if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-               ZVAL_COPY_VALUE(&tmp, varname);
-               zval_copy_ctor(&tmp);
-               convert_to_string(&tmp);
-               varname = &tmp;
-       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-               Z_ADDREF_P(varname);
-       }
-
-       if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-               zend_std_unset_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-       } else {
-               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
-               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
-       }
-
-       if (IS_CV != IS_CONST && varname == &tmp) {
-               zval_dtor(&tmp);
-       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-               zval_ptr_dtor(&varname);
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -24833,73 +26404,6 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        }
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       USE_OPLINE
-       zval **value;
-       zend_bool isset = 1;
-
-       SAVE_OPLINE();
-       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
-               if (EX_CV(opline->op1.var)) {
-                       value = EX_CV(opline->op1.var);
-               } else if (EG(active_symbol_table)) {
-                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               } else {
-                       isset = 0;
-               }
-       } else {
-               HashTable *target_symbol_table;
-
-               zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
-
-               if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-                       ZVAL_COPY_VALUE(&tmp, varname);
-                       zval_copy_ctor(&tmp);
-                       convert_to_string(&tmp);
-                       varname = &tmp;
-               }
-
-               if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC_MEMBER) {
-                       value = zend_std_get_static_property(EX_T(opline->op2.var).class_entry, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-                       if (!value) {
-                               isset = 0;
-                       }
-               } else {
-                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
-                               isset = 0;
-                       }
-               }
-
-               if (IS_CV != IS_CONST && varname == &tmp) {
-                       zval_dtor(&tmp);
-               }
-
-       }
-
-       if (opline->extended_value & ZEND_ISSET) {
-               if (isset && Z_TYPE_PP(value) != IS_NULL) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-               if (!isset || !i_zend_is_true(*value)) {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
-               } else {
-                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
-               }
-       }
-
-       CHECK_EXCEPTION();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 #if 0 || (IS_CV != IS_UNUSED)
@@ -25725,6 +27229,157 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
        return zend_post_incdec_property_helper_SPEC_CV_CONST(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CV == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CV != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CV == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CV != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -26509,6 +28164,65 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_CONST != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_CONST == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CV != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -26643,6 +28357,80 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+               if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_CONST != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_CONST == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CV != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -29346,6 +31134,157 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
        return zend_post_incdec_property_helper_SPEC_CV_VAR(decrement_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CV == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CV != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CV == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CV != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -30187,6 +32126,65 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_VAR != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_VAR == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CV != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -30321,6 +32319,80 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
        ZEND_VM_NEXT_OPCODE();
 }
 
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+               if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_VAR != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_VAR == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CV != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -30725,6 +32797,157 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_
        return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
+static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zend_free_op free_op1;
+       zval *varname;
+       zval **retval;
+       zval tmp_varname;
+       HashTable *target_symbol_table;
+       ulong hash_value;
+
+       SAVE_OPLINE();
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
+               ZVAL_COPY_VALUE(&tmp_varname, varname);
+               zval_copy_ctor(&tmp_varname);
+               convert_to_string(&tmp_varname);
+               varname = &tmp_varname;
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+
+       } else {
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+/*
+               if (!target_symbol_table) {
+                       CHECK_EXCEPTION();
+                       ZEND_VM_NEXT_OPCODE();
+               }
+*/
+               if (IS_CV == IS_CONST) {
+                       hash_value = Z_HASH_P(varname);
+               } else if (IS_INTERNED(Z_STRVAL_P(varname))) {
+                       hash_value = INTERNED_HASH(Z_STRVAL_P(varname));
+               } else {
+                       hash_value = zend_hash_func(Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1);
+               }
+
+               if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+                       switch (type) {
+                               case BP_VAR_R:
+                               case BP_VAR_UNSET:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_IS:
+                                       retval = &EG(uninitialized_zval_ptr);
+                                       break;
+                               case BP_VAR_RW:
+                                       zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+                                       /* break missing intentionally */
+                               case BP_VAR_W:
+                                       Z_ADDREF_P(&EG(uninitialized_zval));
+                                       zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+                                       break;
+                               EMPTY_SWITCH_DEFAULT_CASE()
+                       }
+               }
+               switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
+                       case ZEND_FETCH_GLOBAL:
+                               if (IS_CV != IS_TMP_VAR) {
+
+                               }
+                               break;
+                       case ZEND_FETCH_LOCAL:
+
+                               break;
+                       case ZEND_FETCH_STATIC:
+                               zval_update_constant(retval, (void*) 1 TSRMLS_CC);
+                               break;
+                       case ZEND_FETCH_GLOBAL_LOCK:
+                               if (IS_CV == IS_VAR && !free_op1.var) {
+                                       PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+                               }
+                               break;
+               }
+       }
+
+
+       if (IS_CV != IS_CONST && varname == &tmp_varname) {
+               zval_dtor(&tmp_varname);
+       }
+       if (RETURN_VALUE_USED(opline)) {
+               if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
+                       SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+               }
+               PZVAL_LOCK(*retval);
+               switch (type) {
+                       case BP_VAR_R:
+                       case BP_VAR_IS:
+                               AI_SET_PTR(&EX_T(opline->result.var), *retval);
+                               break;
+                       case BP_VAR_UNSET: {
+                               zend_free_op free_res;
+
+                               PZVAL_UNLOCK(*retval, &free_res);
+                               if (retval != &EG(uninitialized_zval_ptr)) {
+                                       SEPARATE_ZVAL_IF_NOT_REF(retval);
+                               }
+                               PZVAL_LOCK(*retval);
+                               FREE_OP_VAR_PTR(free_res);
+                       }
+                       /* break missing intentionally */
+                       default:
+                               EX_T(opline->result.var).var.ptr_ptr = retval;
+                               break;
+               }
+       }
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_RW, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))?BP_VAR_W:BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_UNSET, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
+static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_IS, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+}
+
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -30989,6 +33212,139 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
        }
 }
 
+static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval tmp, *varname;
+       HashTable *target_symbol_table;
+
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
+                       EX_CV(opline->op1.var) = NULL;
+               } else if (EX_CV(opline->op1.var)) {
+                       zval_ptr_dtor(EX_CV(opline->op1.var));
+                       EX_CV(opline->op1.var) = NULL;
+               }
+               CHECK_EXCEPTION();
+               ZEND_VM_NEXT_OPCODE();
+       }
+
+       varname = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+       if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+               ZVAL_COPY_VALUE(&tmp, varname);
+               zval_copy_ctor(&tmp);
+               convert_to_string(&tmp);
+               varname = &tmp;
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               Z_ADDREF_P(varname);
+       }
+
+       if (IS_UNUSED != IS_UNUSED) {
+               zend_class_entry *ce;
+
+               if (IS_UNUSED == IS_CONST) {
+                       ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+               } else {
+                       ce = EX_T(opline->op2.var).class_entry;
+               }
+               zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+       } else {
+               ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
+
+               target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+               zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+       }
+
+       if (IS_CV != IS_CONST && varname == &tmp) {
+               zval_dtor(&tmp);
+       } else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+               zval_ptr_dtor(&varname);
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+       USE_OPLINE
+       zval **value;
+       zend_bool isset = 1;
+
+       SAVE_OPLINE();
+       if (IS_CV == IS_CV && (opline->extended_value & ZEND_QUICK_SET)) {
+               if (EX_CV(opline->op1.var)) {
+                       value = EX_CV(opline->op1.var);
+               } else if (EG(active_symbol_table)) {
+                       zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
+
+                       if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               } else {
+                       isset = 0;
+               }
+       } else {
+               HashTable *target_symbol_table;
+
+               zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+
+               if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
+                       ZVAL_COPY_VALUE(&tmp, varname);
+                       zval_copy_ctor(&tmp);
+                       convert_to_string(&tmp);
+                       varname = &tmp;
+               }
+
+               if (IS_UNUSED != IS_UNUSED) {
+                       zend_class_entry *ce;
+
+                       if (IS_UNUSED == IS_CONST) {
+                               ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                       } else {
+                               ce = EX_T(opline->op2.var).class_entry;
+                       }
+                       value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       if (!value) {
+                               isset = 0;
+                       }
+               } else {
+                       target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
+                       if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+                               isset = 0;
+                       }
+               }
+
+               if (IS_CV != IS_CONST && varname == &tmp) {
+                       zval_dtor(&tmp);
+               }
+
+       }
+
+       if (opline->extended_value & ZEND_ISSET) {
+               if (isset && Z_TYPE_PP(value) != IS_NULL) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       } else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
+               if (!isset || !i_zend_is_true(*value)) {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+               } else {
+                       ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+               }
+       }
+
+       CHECK_EXCEPTION();
+       ZEND_VM_NEXT_OPCODE();
+}
+
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
@@ -34708,31 +37064,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
        ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
        ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CONST_HANDLER,
-       ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
-       ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
-       ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
-       ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
-       ZEND_UNSET_VAR_SPEC_TMP_HANDLER,
-       ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
-       ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
-       ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
-       ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
-       ZEND_UNSET_VAR_SPEC_VAR_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER,
+       ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER,
+       ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CV_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CV_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CV_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CV_HANDLER,
-       ZEND_UNSET_VAR_SPEC_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER,
+       ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -34858,31 +37214,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_EXIT_SPEC_CV_HANDLER,
        ZEND_EXIT_SPEC_CV_HANDLER,
        ZEND_EXIT_SPEC_CV_HANDLER,
-       ZEND_FETCH_R_SPEC_CONST_HANDLER,
-       ZEND_FETCH_R_SPEC_CONST_HANDLER,
-       ZEND_FETCH_R_SPEC_CONST_HANDLER,
-       ZEND_FETCH_R_SPEC_CONST_HANDLER,
-       ZEND_FETCH_R_SPEC_CONST_HANDLER,
-       ZEND_FETCH_R_SPEC_TMP_HANDLER,
-       ZEND_FETCH_R_SPEC_TMP_HANDLER,
-       ZEND_FETCH_R_SPEC_TMP_HANDLER,
-       ZEND_FETCH_R_SPEC_TMP_HANDLER,
-       ZEND_FETCH_R_SPEC_TMP_HANDLER,
-       ZEND_FETCH_R_SPEC_VAR_HANDLER,
-       ZEND_FETCH_R_SPEC_VAR_HANDLER,
-       ZEND_FETCH_R_SPEC_VAR_HANDLER,
-       ZEND_FETCH_R_SPEC_VAR_HANDLER,
-       ZEND_FETCH_R_SPEC_VAR_HANDLER,
+       ZEND_FETCH_R_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_VAR_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_R_SPEC_VAR_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_R_SPEC_CV_HANDLER,
-       ZEND_FETCH_R_SPEC_CV_HANDLER,
-       ZEND_FETCH_R_SPEC_CV_HANDLER,
-       ZEND_FETCH_R_SPEC_CV_HANDLER,
-       ZEND_FETCH_R_SPEC_CV_HANDLER,
+       ZEND_FETCH_R_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_R_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -34933,31 +37289,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_OBJ_R_SPEC_CV_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER,
-       ZEND_FETCH_W_SPEC_CONST_HANDLER,
-       ZEND_FETCH_W_SPEC_CONST_HANDLER,
-       ZEND_FETCH_W_SPEC_CONST_HANDLER,
-       ZEND_FETCH_W_SPEC_CONST_HANDLER,
-       ZEND_FETCH_W_SPEC_CONST_HANDLER,
-       ZEND_FETCH_W_SPEC_TMP_HANDLER,
-       ZEND_FETCH_W_SPEC_TMP_HANDLER,
-       ZEND_FETCH_W_SPEC_TMP_HANDLER,
-       ZEND_FETCH_W_SPEC_TMP_HANDLER,
-       ZEND_FETCH_W_SPEC_TMP_HANDLER,
-       ZEND_FETCH_W_SPEC_VAR_HANDLER,
-       ZEND_FETCH_W_SPEC_VAR_HANDLER,
-       ZEND_FETCH_W_SPEC_VAR_HANDLER,
-       ZEND_FETCH_W_SPEC_VAR_HANDLER,
-       ZEND_FETCH_W_SPEC_VAR_HANDLER,
+       ZEND_FETCH_W_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_VAR_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_W_SPEC_VAR_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_CV_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_W_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_W_SPEC_CV_HANDLER,
-       ZEND_FETCH_W_SPEC_CV_HANDLER,
-       ZEND_FETCH_W_SPEC_CV_HANDLER,
-       ZEND_FETCH_W_SPEC_CV_HANDLER,
-       ZEND_FETCH_W_SPEC_CV_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -35008,31 +37364,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER,
-       ZEND_FETCH_RW_SPEC_CONST_HANDLER,
-       ZEND_FETCH_RW_SPEC_CONST_HANDLER,
-       ZEND_FETCH_RW_SPEC_CONST_HANDLER,
-       ZEND_FETCH_RW_SPEC_CONST_HANDLER,
-       ZEND_FETCH_RW_SPEC_CONST_HANDLER,
-       ZEND_FETCH_RW_SPEC_TMP_HANDLER,
-       ZEND_FETCH_RW_SPEC_TMP_HANDLER,
-       ZEND_FETCH_RW_SPEC_TMP_HANDLER,
-       ZEND_FETCH_RW_SPEC_TMP_HANDLER,
-       ZEND_FETCH_RW_SPEC_TMP_HANDLER,
-       ZEND_FETCH_RW_SPEC_VAR_HANDLER,
-       ZEND_FETCH_RW_SPEC_VAR_HANDLER,
-       ZEND_FETCH_RW_SPEC_VAR_HANDLER,
-       ZEND_FETCH_RW_SPEC_VAR_HANDLER,
-       ZEND_FETCH_RW_SPEC_VAR_HANDLER,
+       ZEND_FETCH_RW_SPEC_CONST_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_TMP_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_VAR_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_RW_SPEC_VAR_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_RW_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_RW_SPEC_CV_HANDLER,
-       ZEND_FETCH_RW_SPEC_CV_HANDLER,
-       ZEND_FETCH_RW_SPEC_CV_HANDLER,
-       ZEND_FETCH_RW_SPEC_CV_HANDLER,
-       ZEND_FETCH_RW_SPEC_CV_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -35083,31 +37439,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER,
-       ZEND_FETCH_IS_SPEC_CONST_HANDLER,
-       ZEND_FETCH_IS_SPEC_CONST_HANDLER,
-       ZEND_FETCH_IS_SPEC_CONST_HANDLER,
-       ZEND_FETCH_IS_SPEC_CONST_HANDLER,
-       ZEND_FETCH_IS_SPEC_CONST_HANDLER,
-       ZEND_FETCH_IS_SPEC_TMP_HANDLER,
-       ZEND_FETCH_IS_SPEC_TMP_HANDLER,
-       ZEND_FETCH_IS_SPEC_TMP_HANDLER,
-       ZEND_FETCH_IS_SPEC_TMP_HANDLER,
-       ZEND_FETCH_IS_SPEC_TMP_HANDLER,
-       ZEND_FETCH_IS_SPEC_VAR_HANDLER,
-       ZEND_FETCH_IS_SPEC_VAR_HANDLER,
-       ZEND_FETCH_IS_SPEC_VAR_HANDLER,
-       ZEND_FETCH_IS_SPEC_VAR_HANDLER,
-       ZEND_FETCH_IS_SPEC_VAR_HANDLER,
+       ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_TMP_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_VAR_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_IS_SPEC_CV_HANDLER,
-       ZEND_FETCH_IS_SPEC_CV_HANDLER,
-       ZEND_FETCH_IS_SPEC_CV_HANDLER,
-       ZEND_FETCH_IS_SPEC_CV_HANDLER,
-       ZEND_FETCH_IS_SPEC_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_IS_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -35158,31 +37514,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CONST_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_TMP_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_VAR_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
-       ZEND_FETCH_FUNC_ARG_SPEC_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -35233,31 +37589,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CONST_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_TMP_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_VAR_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
-       ZEND_FETCH_UNSET_SPEC_CV_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER,
+       ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -35708,31 +38064,31 @@ void zend_init_opcodes_handlers(void)
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER,
        ZEND_NULL_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER,
+       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
-       ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,