Modified: php/php-src/trunk/NEWS
===================================================================
--- php/php-src/trunk/NEWS	2010-05-06 08:37:41 UTC (rev 299060)
+++ php/php-src/trunk/NEWS	2010-05-06 10:27:35 UTC (rev 299061)
@@ -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

Modified: php/php-src/trunk/Zend/zend_compile.c
===================================================================
--- php/php-src/trunk/Zend/zend_compile.c	2010-05-06 08:37:41 UTC (rev 299060)
+++ php/php-src/trunk/Zend/zend_compile.c	2010-05-06 10:27:35 UTC (rev 299061)
@@ -360,6 +360,7 @@
 	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 @@
 	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 @@
 		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 @@
 			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;
 		}
 	}

Modified: php/php-src/trunk/Zend/zend_vm_def.h
===================================================================
--- php/php-src/trunk/Zend/zend_vm_def.h	2010-05-06 08:37:41 UTC (rev 299060)
+++ php/php-src/trunk/Zend/zend_vm_def.h	2010-05-06 10:27:35 UTC (rev 299061)
@@ -1011,7 +1011,7 @@
 	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 @@
 		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_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 @@
 		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_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 @@
 		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_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 @@
 			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;
 			}

Modified: php/php-src/trunk/Zend/zend_vm_execute.h
===================================================================
--- php/php-src/trunk/Zend/zend_vm_execute.h	2010-05-06 08:37:41 UTC (rev 299060)
+++ php/php-src/trunk/Zend/zend_vm_execute.h	2010-05-06 10:27:35 UTC (rev 299061)
@@ -1475,150 +1475,6 @@
 	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 @@
 	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_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 @@
 	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_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 @@
 	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_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_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 @@
 	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 @@
 	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_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 @@
 	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_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 @@
 	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_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_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 @@
 	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 @@
 	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 @@
 	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 @@
 	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_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 @@
 	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 @@
 	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_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 @@
 	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 @@
 	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_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 @@
 	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 @@
 	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_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 @@
 	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_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 @@
 	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 @@
 	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_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 @@
 	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 @@
 	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_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,41 +37064,41 @@
   	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_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_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_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,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER,
   	ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER,
   	ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER,
@@ -34858,41 +37214,41 @@
   	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_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_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_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,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER,
@@ -34933,41 +37289,41 @@
   	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_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_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_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER,
@@ -35008,41 +37364,41 @@
   	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_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_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_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER,
@@ -35083,41 +37439,41 @@
   	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_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_FETCH_IS_SPEC_VAR_VAR_HANDLER,
+  	ZEND_FETCH_IS_SPEC_VAR_UNUSED_HANDLER,
   	ZEND_NULL_HANDLER,
   	ZEND_NULL_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,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER,
@@ -35158,41 +37514,41 @@
   	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_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_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_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,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER,
@@ -35233,41 +37589,41 @@
   	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_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_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_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,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER,
   	ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER,
   	ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER,
@@ -35708,41 +38064,41 @@
   	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_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_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_NULL_HANDLER,
   	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
+  	ZEND_NULL_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER,
   	ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER,