Split IS_BOOL into IS_FALSE and IS_TRUE

18 files changed, 951 insertions, 567 deletions

diff --git a/Zend/zend.c b/Zend/zend.c
index 465446d663..f4bab5032c 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -220,19 +220,15 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 
 again:
 	switch (Z_TYPE_P(expr)) {
-		case IS_NULL: {
+		case IS_NULL:
+		case IS_FALSE: {
 			TSRMLS_FETCH();
 			ZVAL_EMPTY_STRING(expr_copy);
 			break;
 		}
-		case IS_BOOL:
-			if (Z_LVAL_P(expr)) {
-				// TODO: use interned string ???
-				ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
-			} else {
-				TSRMLS_FETCH();
-				ZVAL_EMPTY_STRING(expr_copy);
-			}
+		case IS_TRUE:
+			// TODO: use interned string ???
+			ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
 			break;
 		case IS_RESOURCE: {
 				char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
@@ -1201,7 +1197,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 			ZVAL_UNDEF(&retval);
 			if (call_user_function_ex(CG(function_table), NULL, &orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
 				if (Z_TYPE(retval) != IS_UNDEF) {
-					if (Z_TYPE(retval) == IS_BOOL && Z_LVAL(retval) == 0) {
+					if (Z_TYPE(retval) == IS_FALSE) {
 						zend_error_cb(type, error_filename, error_lineno, format, args);
 					}
 					zval_ptr_dtor(&retval);
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 60ef092bb1..6c023f474d 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -201,7 +201,8 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D) /* {{{ */
 ZEND_API char *zend_get_type_by_const(int type) /* {{{ */
 {
 	switch(type) {
-		case IS_BOOL:
+		case IS_FALSE:
+		case IS_TRUE:
 			return "boolean";
 		case IS_LONG:
 			return "integer";
@@ -408,8 +409,9 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 							}
 						}
 					case IS_NULL:
+					case IS_FALSE:
+					case IS_TRUE:
 					case IS_LONG:
-					case IS_BOOL:
 						convert_to_long_ex(arg);
 						*p = Z_LVAL_P(arg);
 						break;
@@ -447,9 +449,10 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 						break;
 
 					case IS_NULL:
+					case IS_FALSE:
+					case IS_TRUE:
 					case IS_LONG:
 					case IS_DOUBLE:
-					case IS_BOOL:
 						convert_to_double_ex(arg);
 						*p = Z_DVAL_P(arg);
 						break;
@@ -480,7 +483,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 					case IS_STRING:
 					case IS_LONG:
 					case IS_DOUBLE:
-					case IS_BOOL:
+					case IS_FALSE:
+					case IS_TRUE:
 						convert_to_string_ex(arg);
 						if (UNEXPECTED(Z_ISREF_P(arg))) {
 							/* it's dangerous to return pointers to string
@@ -525,7 +529,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 					case IS_STRING:
 					case IS_LONG:
 					case IS_DOUBLE:
-					case IS_BOOL:
+					case IS_FALSE:
+					case IS_TRUE:
 						convert_to_string_ex(arg);
 						if (UNEXPECTED(Z_ISREF_P(arg))) {
 							/* it's dangerous to return pointers to string
@@ -563,9 +568,10 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 					case IS_STRING:
 					case IS_LONG:
 					case IS_DOUBLE:
-					case IS_BOOL:
+					case IS_FALSE:
+					case IS_TRUE:
 						convert_to_boolean_ex(arg);
-						*p = Z_BVAL_P(arg);
+						*p = Z_TYPE_P(arg) == IS_TRUE;
 						break;
 
 					case IS_ARRAY:
@@ -1641,7 +1647,12 @@ ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC)
 			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key));
 			result = zend_hash_index_update(ht, Z_RES_HANDLE_P(key), value);
 			break;
-		case IS_BOOL:
+		case IS_FALSE:
+			result = zend_hash_index_update(ht, 0, value);
+			break;
+		case IS_TRUE:
+			result = zend_hash_index_update(ht, 1, value);
+			break;
 		case IS_LONG:
 			result = zend_hash_index_update(ht, Z_LVAL_P(key), value);
 			break;
@@ -3954,8 +3965,9 @@ static int same_zval(zval *zv1, zval *zv2)  /* {{{ */
 	switch (Z_TYPE_P(zv1)) {
 		case IS_UNDEF:
 		case IS_NULL:
+		case IS_FALSE:
+		case IS_TRUE:
 			return 1;
-		case IS_BOOL:
 		case IS_LONG:
 			return Z_LVAL_P(zv1) == Z_LVAL_P(zv2);
 		case IS_DOUBLE:
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index ae26375f70..54402c411d 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -594,9 +594,6 @@ END_EXTERN_C()
 	    }										\
 	} while (0)
 
-#define ZVAL_FALSE(z)  					ZVAL_BOOL(z, 0)
-#define ZVAL_TRUE(z)  					ZVAL_BOOL(z, 1)
-
 #define RETVAL_BOOL(b)					ZVAL_BOOL(return_value, b)
 #define RETVAL_NULL() 					ZVAL_NULL(return_value)
 #define RETVAL_LONG(l) 					ZVAL_LONG(return_value, l)
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 32bd68e58e..80f3818d17 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -686,7 +686,8 @@ repeat:
 		case IS_LONG:
 		case IS_DOUBLE:
 		case IS_STRING:
-		case IS_BOOL:
+		case IS_FALSE:
+		case IS_TRUE:
 		case IS_RESOURCE:
 		case IS_NULL:
 			break;
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 8df612e18b..02dca941ba 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -3494,14 +3494,12 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 
 						ZVAL_DUP(&zv, precv->op2.zv);
 						zval_update_constant_ex(&zv, 1, fptr->common.scope TSRMLS_CC);
-						if (Z_TYPE(zv) == IS_BOOL) {
-							if (Z_LVAL(zv)) {
-								memcpy(offset, "true", 4);
-								offset += 4;
-							} else {
-								memcpy(offset, "false", 5);
-								offset += 5;
-							}
+						if (Z_TYPE(zv) == IS_FALSE) {
+							memcpy(offset, "false", 5);
+							offset += 5;
+						} else if (Z_TYPE(zv) == IS_TRUE) {
+							memcpy(offset, "true", 4);
+							offset += 4;
 						} else if (Z_TYPE(zv) == IS_NULL) {
 							memcpy(offset, "NULL", 4);
 							offset += 4;
@@ -5973,9 +5971,14 @@ void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr
 				zend_symtable_update(Z_ARRVAL(result->u.constant), STR_EMPTY_ALLOC(), &element);
 				break;
 			case IS_LONG:
-			case IS_BOOL:
 				zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element);
 				break;
+			case IS_FALSE:
+				zend_hash_index_update(Z_ARRVAL(result->u.constant), 0, &element);
+				break;
+			case IS_TRUE:
+				zend_hash_index_update(Z_ARRVAL(result->u.constant), 1, &element);
+				break;
 			case IS_DOUBLE:
 				zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element);
 				break;
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index 137d9c97f8..8b89796179 100644
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -456,12 +456,11 @@ static int _build_trace_args(zval *arg TSRMLS_DC, int num_args, va_list args, ze
 			}
 			break;
 		}
-		case IS_BOOL:
-			if (Z_LVAL_P(arg)) {
-				TRACE_APPEND_STR("true, ");
-			} else {
-				TRACE_APPEND_STR("false, ");
-			}
+		case IS_FALSE:
+			TRACE_APPEND_STR("false, ");
+			break;
+		case IS_TRUE:
+			TRACE_APPEND_STR("true, ");
 			break;
 		case IS_RESOURCE: {
 			long lval = Z_RES_HANDLE_P(arg);
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 8b3ea40eb6..5ed46788eb 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -503,7 +503,7 @@ static inline zval* make_real_object(zval *object_ptr TSRMLS_DC)
 	ZVAL_DEREF(object);
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		if (Z_TYPE_P(object) == IS_NULL
-			|| (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0)
+			|| Z_TYPE_P(object) == IS_FALSE
 			|| (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
 			if (EXPECTED(object == object_ptr)) {
 				/* object_ptr is not a reference */
@@ -678,7 +678,7 @@ static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *p
 			return;
 		}
 		if (Z_TYPE_P(object) == IS_NULL ||
-		    (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0) ||
+		    Z_TYPE_P(object) == IS_FALSE ||
 		    (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
 //??? The following block may handle only non-interned empty string,
 //??? but it doesn't work anyway
@@ -1093,8 +1093,11 @@ str_index:
 				zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim));
 				hval = Z_RES_HANDLE_P(dim);
 				goto num_index;
-			case IS_BOOL:
-				hval = Z_LVAL_P(dim);
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
 				goto num_index;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
@@ -1162,7 +1165,8 @@ convert_to_array:
 					break;
 				case IS_DOUBLE:
 				case IS_NULL:
-				case IS_BOOL:
+				case IS_FALSE:
+				case IS_TRUE:
 					zend_error(E_NOTICE, "String offset cast occurred");
 					break;
 				default:
@@ -1226,8 +1230,7 @@ convert_to_array:
 		}
 	} else {
 		if (type != BP_VAR_UNSET &&
-		    Z_TYPE_P(container) == IS_BOOL &&
-		    Z_LVAL_P(container)==0) {
+		    Z_TYPE_P(container) == IS_FALSE) {
 			goto convert_to_array;
 		}
 		if (type == BP_VAR_UNSET) {
@@ -1284,7 +1287,8 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z
 					break;
 				case IS_DOUBLE:
 				case IS_NULL:
-				case IS_BOOL:
+				case IS_FALSE:
+				case IS_TRUE:
 					if (type != BP_VAR_IS) {
 						zend_error(E_NOTICE, "String offset cast occurred");
 					}
@@ -1358,8 +1362,8 @@ static void zend_fetch_property_address(zval *result, zval *container_ptr, zval
 		/* this should modify object only if it's empty */
 		if (type != BP_VAR_UNSET &&
 		    ((Z_TYPE_P(container) == IS_NULL ||
-		     (Z_TYPE_P(container) == IS_BOOL && Z_LVAL_P(container)==0) ||
-		     (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
+		      Z_TYPE_P(container) == IS_FALSE ||
+		      (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
 			if (container == container_ptr) {
 				SEPARATE_ZVAL(container);
 			}
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 98e2678f53..0cdaeabde0 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -80,13 +80,18 @@ again:
 	switch (Z_TYPE_P(op)) {
 		case IS_UNDEF:
 		case IS_NULL:
+		case IS_FALSE:
 			result = 0;
 			break;
+		case IS_TRUE:
+			result = 1;
+			break;
 		case IS_LONG:
-		case IS_BOOL:
-		case IS_RESOURCE:
 			result = (Z_LVAL_P(op)?1:0);
 			break;
+		case IS_RESOURCE:
+			result = (Z_RES_HANDLE_P(op)?1:0);
+			break;
 		case IS_DOUBLE:
 			result = (Z_DVAL_P(op) ? 1 : 0);
 			break;
@@ -105,8 +110,8 @@ again:
 			if (IS_ZEND_STD_OBJECT(*op)) {
 				if (Z_OBJ_HT_P(op)->cast_object) {
 					zval tmp;
-					if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
-						result = Z_LVAL(tmp);
+					if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL TSRMLS_CC) == SUCCESS) {
+						result = Z_TYPE(tmp) == IS_TRUE;
 						break;
 					}
 				} else if (Z_OBJ_HT_P(op)->get) {
@@ -115,7 +120,7 @@ again:
 					if (Z_TYPE_P(tmp) != IS_OBJECT) {
 						/* for safety - avoid loop */
 						convert_to_boolean(tmp);
-						result = Z_LVAL_P(tmp);
+						result = Z_TYPE_P(tmp) == IS_TRUE;
 						zval_ptr_dtor(tmp);
 						break;
 					}
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index a7d7a948a5..7041563704 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -685,7 +685,12 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
 				case IS_STRING:
 					ret = zend_symtable_update_current_key_ex(Z_ARRVAL_P(p), Z_STR_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
 					break;
-				case IS_BOOL:
+				case IS_FALSE:
+					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, HASH_UPDATE_KEY_IF_BEFORE);
+					break;
+				case IS_TRUE:
+					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 1, HASH_UPDATE_KEY_IF_BEFORE);
+					break;
 				case IS_LONG:
 					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, Z_LVAL_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
 					break;
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index ace4f6c284..6f39f4d63f 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -839,7 +839,7 @@ expr_without_variable:
 	|	T_STRING_CAST expr	{ zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
 	|	T_ARRAY_CAST expr 	{ zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
 	|	T_OBJECT_CAST expr 	{ zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
-	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, IS_BOOL TSRMLS_CC); }
+	|	T_BOOL_CAST expr	{ zend_do_cast(&$$, &$2, _IS_BOOL TSRMLS_CC); }
 	|	T_UNSET_CAST expr	{ zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
 	|	T_EXIT exit_expr	{ zend_do_exit(&$$, &$2 TSRMLS_CC); }
 	|	'@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }
diff --git a/Zend/zend_list.c b/Zend/zend_list.c
index c9b9ff66df..7892b7057c 100644
--- a/Zend/zend_list.c
+++ b/Zend/zend_list.c
@@ -37,6 +37,9 @@ ZEND_API zval *zend_list_insert(void *ptr, int type TSRMLS_DC)
 	zval zv;
 
 	index = zend_hash_next_free_element(&EG(regular_list));
+	if (index == 0) {
+		index = 1;
+	}
 	ZVAL_NEW_RES(&zv, index, ptr, type);
 	return zend_hash_index_update(&EG(regular_list), index, &zv);
 }
diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index a41452dae8..64ef01b977 100644
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -1570,7 +1570,7 @@ ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int ty
 				}
 			}
 			return FAILURE;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(writeobj, 1);
 			return SUCCESS;
 		case IS_LONG:
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 7d4518adbc..a72a75b1f3 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -204,8 +204,12 @@ try_again:
 				STR_RELEASE(str);
 				break;
 			}
-		case IS_BOOL:
-			Z_TYPE_INFO_P(op) = IS_LONG;
+		case IS_NULL:
+		case IS_FALSE:
+			ZVAL_LONG(op, 0);
+			break;
+		case IS_TRUE:
+			ZVAL_LONG(op, 1);
 			break;
 		case IS_RESOURCE:
 			{
@@ -217,9 +221,6 @@ try_again:
 		case IS_OBJECT:
 			convert_to_long_base(op, 10);
 			break;
-		case IS_NULL:
-			ZVAL_LONG(op, 0);
-			break;
 	}
 }
 /* }}} */
@@ -240,16 +241,17 @@ try_again:
 					(op) = &(holder);										\
 					break;													\
 				}															\
-			case IS_BOOL:													\
-				ZVAL_LONG(&(holder), Z_LVAL_P(op));							\
+			case IS_NULL:													\
+			case IS_FALSE:													\
+				ZVAL_LONG(&(holder), 0);									\
 				(op) = &(holder);											\
 				break;														\
-			case IS_RESOURCE:												\
-				ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));					\
+			case IS_TRUE:													\
+				ZVAL_LONG(&(holder), 1);									\
 				(op) = &(holder);											\
 				break;														\
-			case IS_NULL:													\
-				ZVAL_LONG(&(holder), 0);									\
+			case IS_RESOURCE:												\
+				ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));					\
 				(op) = &(holder);											\
 				break;														\
 			case IS_OBJECT:													\
@@ -271,7 +273,11 @@ try_again:
 	} else if (Z_TYPE_P(op) != IS_LONG) {							\
 		switch (Z_TYPE_P(op)) {										\
 			case IS_NULL:											\
-				ZVAL_LONG(&holder, 0);								\
+			case IS_FALSE:											\
+				ZVAL_LONG(&(holder), 0);							\
+				break;												\
+			case IS_TRUE:											\
+				ZVAL_LONG(&(holder), 1);							\
 				break;												\
 			case IS_DOUBLE:											\
 				ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\
@@ -286,9 +292,6 @@ try_again:
 				ZVAL_DUP(&(holder), (op));							\
 				convert_to_long_base(&(holder), 10);				\
 				break;												\
-			case IS_BOOL:											\
-				ZVAL_LONG(&(holder), Z_LVAL_P(op));					\
-				break;												\
 			case IS_RESOURCE:										\
 				ZVAL_LONG(&holder, Z_RES_HANDLE_P(op));				\
 				break;												\
@@ -306,7 +309,8 @@ try_again:
 #define zendi_convert_to_boolean(op, holder, result)				\
 	if (op==result) {												\
 		convert_to_boolean(op);										\
-	} else if (Z_TYPE_P(op) != IS_BOOL) {							\
+	} else if (Z_TYPE_P(op) != IS_FALSE &&							\
+	           Z_TYPE_P(op) != IS_TRUE) {							\
 		switch (Z_TYPE_P(op)) {										\
 			case IS_NULL:											\
 				ZVAL_BOOL(&holder, 0);								\
@@ -378,15 +382,18 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
 
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
+		case IS_FALSE:
 			ZVAL_LONG(op, 0);
 			break;
+		case IS_TRUE:
+			ZVAL_LONG(op, 1);
+			break;
 		case IS_RESOURCE: {
 				long l = Z_RES_HANDLE_P(op);
 				zval_ptr_dtor(op);
 				ZVAL_LONG(op, l);
 			}
 			/* break missing intentionally */
-		case IS_BOOL:
 			Z_TYPE_INFO_P(op) = IS_LONG;
 			break;
 		case IS_LONG:
@@ -439,15 +446,18 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
 
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
+		case IS_FALSE:
 			ZVAL_DOUBLE(op, 0.0);
 			break;
+		case IS_TRUE:
+			ZVAL_DOUBLE(op, 1.0);
+			break;
 		case IS_RESOURCE: {
 				double d = (double) Z_RES_HANDLE_P(op);
 				zval_ptr_dtor(op);
 				ZVAL_DOUBLE(op, d);
 			}
 			break;
-		case IS_BOOL:
 		case IS_LONG:
 			ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
 			break;
@@ -518,7 +528,8 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
 	int tmp;
 
 	switch (Z_TYPE_P(op)) {
-		case IS_BOOL:
+		case IS_FALSE:
+		case IS_TRUE:
 			break;
 		case IS_NULL:
 			ZVAL_BOOL(op, 0);
@@ -559,10 +570,10 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
 				zval dst;
 				TSRMLS_FETCH();
 
-				convert_object_to_type(op, &dst, IS_BOOL, convert_to_boolean);
+				convert_object_to_type(op, &dst, _IS_BOOL, convert_to_boolean);
 				zval_dtor(op);
 
-				if (Z_TYPE(dst) == IS_BOOL) {
+				if (Z_TYPE(dst) == IS_FALSE || Z_TYPE(dst) == IS_TRUE) {
 					ZVAL_COPY_VALUE(op, &dst);
 				} else {
 					ZVAL_BOOL(op, 1);
@@ -589,20 +600,16 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 	double dval;
 
 	switch (Z_TYPE_P(op)) {
-		case IS_NULL: {
+		case IS_NULL:
+		case IS_FALSE: {
 			TSRMLS_FETCH();
 			ZVAL_EMPTY_STRING(op);
 			break;
 		}
-		case IS_STRING:
+		case IS_TRUE:
+			ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
 			break;
-		case IS_BOOL:
-			if (Z_LVAL_P(op)) {
-				ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
-			} else {
-				TSRMLS_FETCH();
-				ZVAL_EMPTY_STRING(op);
-			}
+		case IS_STRING:
 			break;
 		case IS_RESOURCE: {
 			long tmp = Z_RES_HANDLE_P(op);
@@ -812,10 +819,12 @@ ZEND_API long _zval_get_long_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
+		case IS_FALSE:
 			return 0;
+		case IS_TRUE:
+			return 1;
 		case IS_RESOURCE:
 			return Z_RES_HANDLE_P(op);
-		case IS_BOOL:
 		case IS_LONG:
 			return Z_LVAL_P(op);
 		case IS_DOUBLE:
@@ -850,10 +859,12 @@ ZEND_API double _zval_get_double_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
+		case IS_FALSE:
 			return 0.0;
+		case IS_TRUE:
+			return 1.0;
 		case IS_RESOURCE:
 			return (double) Z_RES_HANDLE_P(op);
-		case IS_BOOL:
 		case IS_LONG:
 			return (double) Z_LVAL_P(op);
 		case IS_DOUBLE:
@@ -890,15 +901,12 @@ ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
+		case IS_FALSE:
 			return STR_EMPTY_ALLOC();
 		case IS_STRING:
 			return STR_COPY(Z_STR_P(op));
-		case IS_BOOL:
-			if (Z_BVAL_P(op)) {
-				return STR_INIT("1", 1, 0);
-			} else {
-				return STR_EMPTY_ALLOC();
-			}
+		case IS_TRUE:
+			return STR_INIT("1", 1, 0);
 		case IS_RESOURCE: {
 			char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
 			int len;
@@ -1309,17 +1317,18 @@ ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 	zval op1_copy, op2_copy;
 	long op1_lval;
 
-	if (Z_TYPE_P(op1) != IS_BOOL || Z_TYPE_P(op2) != IS_BOOL) {
+	if ((Z_TYPE_P(op1) != IS_FALSE && Z_TYPE_P(op1) != IS_TRUE) ||
+	    (Z_TYPE_P(op2) != IS_FALSE && Z_TYPE_P(op2) != IS_TRUE)) {
 		ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BOOL_XOR);
 
 		zendi_convert_to_boolean(op1, op1_copy, result);
-		op1_lval = Z_LVAL_P(op1);
+		op1_lval = Z_TYPE_P(op1) == IS_TRUE;
 		zendi_convert_to_boolean(op2, op2_copy, result);
 	} else {
-		op1_lval = Z_LVAL_P(op1);
+		op1_lval = Z_TYPE_P(op1) == IS_TRUE;
 	}
 
-	ZVAL_BOOL(result, op1_lval ^ Z_LVAL_P(op2));
+	ZVAL_BOOL(result, op1_lval ^ (Z_TYPE_P(op2) == IS_TRUE));
 	return SUCCESS;
 }
 /* }}} */
@@ -1328,13 +1337,17 @@ ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
 {
 	zval op1_copy;
 
-	if (Z_TYPE_P(op1) != IS_BOOL) {
+	if (Z_TYPE_P(op1) == IS_FALSE) {
+		ZVAL_TRUE(result);
+	} else if (Z_TYPE_P(op1) == IS_TRUE) {
+		ZVAL_FALSE(result);
+	} else {
 		ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BOOL_NOT);
 
 		zendi_convert_to_boolean(op1, op1_copy, result);
-	}
 
-	ZVAL_BOOL(result, !Z_LVAL_P(op1));
+		ZVAL_BOOL(result, Z_TYPE_P(op1) == IS_FALSE);
+	}
 	return SUCCESS;
 }
 /* }}} */
@@ -1741,19 +1754,19 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 				return SUCCESS;
 
 			case TYPE_PAIR(IS_NULL, IS_NULL):
+			case TYPE_PAIR(IS_NULL, IS_FALSE):
+			case TYPE_PAIR(IS_FALSE, IS_NULL):
+			case TYPE_PAIR(IS_FALSE, IS_FALSE):
+			case TYPE_PAIR(IS_TRUE, IS_TRUE):
 				ZVAL_LONG(result, 0);
 				return SUCCESS;
 
-			case TYPE_PAIR(IS_NULL, IS_BOOL):
-				ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
-				return SUCCESS;
-
-			case TYPE_PAIR(IS_BOOL, IS_NULL):
-				ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+			case TYPE_PAIR(IS_NULL, IS_TRUE):
+				ZVAL_LONG(result, -1);
 				return SUCCESS;
 
-			case TYPE_PAIR(IS_BOOL, IS_BOOL):
-				ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+			case TYPE_PAIR(IS_TRUE, IS_NULL):
+				ZVAL_LONG(result, 1);
 				return SUCCESS;
 
 			case TYPE_PAIR(IS_STRING, IS_STRING):
@@ -1803,7 +1816,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 						return ret;
 					} else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
 						ZVAL_UNDEF(&tmp_free);
-						if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) {
+						if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2)) TSRMLS_CC) == FAILURE) {
 							ZVAL_LONG(result, 1);
 							zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 							return SUCCESS;
@@ -1822,7 +1835,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 						return ret;
 					} else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
 						ZVAL_UNDEF(&tmp_free);
-						if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) {
+						if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1)) TSRMLS_CC) == FAILURE) {
 							ZVAL_LONG(result, -1);
 							zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 							return SUCCESS;
@@ -1840,21 +1853,21 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 				} else if (Z_ISREF_P(op2)) {
 					op2 = Z_REFVAL_P(op2);
 				} else if (!converted) {
-					if (Z_TYPE_P(op1) == IS_NULL) {
+					if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) {
 						zendi_convert_to_boolean(op2, op2_copy, result);
-						ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
+						ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0);
 						return SUCCESS;
-					} else if (Z_TYPE_P(op2) == IS_NULL) {
+					} else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) {
 						zendi_convert_to_boolean(op1, op1_copy, result);
-						ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+						ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0);
 						return SUCCESS;
-					} else if (Z_TYPE_P(op1) == IS_BOOL) {
+					} else if (Z_TYPE_P(op1) == IS_TRUE) {
 						zendi_convert_to_boolean(op2, op2_copy, result);
-						ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+						ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1);
 						return SUCCESS;
-					} else if (Z_TYPE_P(op2) == IS_BOOL) {
+					} else if (Z_TYPE_P(op2) == IS_TRUE) {
 						zendi_convert_to_boolean(op1, op1_copy, result);
-						ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+						ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1);
 						return SUCCESS;
 					} else {
 						zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1895,7 +1908,7 @@ static int hash_zval_identical_function(zval *z1, zval *z2) /* {{{ */
 	if (is_identical_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
 		return 1;
 	}
-	return !Z_LVAL(result);
+	return Z_TYPE(result) != IS_TRUE;
 }
 /* }}} */
 
@@ -1907,9 +1920,10 @@ ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 	}
 	switch (Z_TYPE_P(op1)) {
 		case IS_NULL:
+		case IS_FALSE:
+		case IS_TRUE:
 			ZVAL_BOOL(result, 1);
 			break;
-		case IS_BOOL:
 		case IS_LONG:
 			ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
 			break;
@@ -1951,7 +1965,7 @@ ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS
 	if (is_identical_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
 		return FAILURE;
 	}
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
+	ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
 	return SUCCESS;
 }
 /* }}} */
@@ -2242,7 +2256,7 @@ ZEND_API int decrement_function(zval *op1) /* {{{ */
 ZEND_API int zval_is_true(zval *op) /* {{{ */
 {
 	convert_to_boolean(op);
-	return (Z_LVAL_P(op) ? 1 : 0);
+	return (Z_TYPE_P(op) == IS_TRUE ? 1 : 0);
 }
 /* }}} */
 
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 93a79705c8..b7c8c7e7b2 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -400,7 +400,7 @@ ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
 END_EXTERN_C()
 
 #define convert_to_ex_master(pzv, lower_type, upper_type)	\
-	if (Z_TYPE_P(pzv)!=IS_##upper_type) {					\
+	if (Z_TYPE_P(pzv)!=upper_type) {					\
 		SEPARATE_ZVAL_IF_NOT_REF(pzv);						\
 		convert_to_##lower_type(pzv);						\
 	}
@@ -417,7 +417,7 @@ END_EXTERN_C()
 			case IS_DOUBLE:						\
 				convert_to_double(pzv);			\
 				break;							\
-			case IS_BOOL:						\
+			case _IS_BOOL:						\
 				convert_to_boolean(pzv);		\
 				break;							\
 			case IS_ARRAY:						\
@@ -441,13 +441,13 @@ END_EXTERN_C()
 		convert_to_explicit_type(pzv, str_type);	\
 	}
 
-#define convert_to_boolean_ex(pzv)	convert_to_ex_master(pzv, boolean, BOOL)
-#define convert_to_long_ex(pzv)		convert_to_ex_master(pzv, long, LONG)
-#define convert_to_double_ex(pzv)	convert_to_ex_master(pzv, double, DOUBLE)
-#define convert_to_string_ex(pzv)	convert_to_ex_master(pzv, string, STRING)
-#define convert_to_array_ex(pzv)	convert_to_ex_master(pzv, array, ARRAY)
-#define convert_to_object_ex(pzv)	convert_to_ex_master(pzv, object, OBJECT)
-#define convert_to_null_ex(pzv)		convert_to_ex_master(pzv, null, NULL)
+#define convert_to_boolean_ex(pzv)	convert_to_ex_master(pzv, boolean, _IS_BOOL)
+#define convert_to_long_ex(pzv)		convert_to_ex_master(pzv, long, IS_LONG)
+#define convert_to_double_ex(pzv)	convert_to_ex_master(pzv, double, IS_DOUBLE)
+#define convert_to_string_ex(pzv)	convert_to_ex_master(pzv, string, IS_STRING)
+#define convert_to_array_ex(pzv)	convert_to_ex_master(pzv, array, IS_ARRAY)
+#define convert_to_object_ex(pzv)	convert_to_ex_master(pzv, object, IS_OBJECT)
+#define convert_to_null_ex(pzv)		convert_to_ex_master(pzv, null, IS_NULL)
 
 #define convert_scalar_to_number_ex(pzv)							\
 	if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) {		\
@@ -816,7 +816,7 @@ static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *o
 	return mod_function(result, op1, op2 TSRMLS_CC);
 }
 
-static zend_always_inline int fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_equal_check_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -835,61 +835,115 @@ static zend_always_inline int fast_equal_function(zval *result, zval *op1, zval
 	return Z_LVAL_P(result) == 0;
 }
 
-static zend_always_inline int fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_LVAL_P(op1) != Z_LVAL_P(op2);
+			ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return ((double)Z_LVAL_P(op1)) != Z_DVAL_P(op2);
+			ZVAL_BOOL(result, (double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
+			return;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return Z_DVAL_P(op1) != Z_DVAL_P(op2);
+			ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2));
+			ZVAL_BOOL(result, Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
+			return;
 		}
 	}
 	compare_function(result, op1, op2 TSRMLS_CC);
-	return Z_LVAL_P(result) != 0;
+	ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
 }
 
-static zend_always_inline int fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_LVAL_P(op1) < Z_LVAL_P(op2);
+			ZVAL_BOOL(result, Z_LVAL_P(op1) != Z_LVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return ((double)Z_LVAL_P(op1)) < Z_DVAL_P(op2);
+			ZVAL_BOOL(result, (double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
+			return;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return Z_DVAL_P(op1) < Z_DVAL_P(op2);
+			ZVAL_BOOL(result, Z_DVAL_P(op1) != Z_DVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2));
+			ZVAL_BOOL(result, Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
+			return;
 		}
 	}
 	compare_function(result, op1, op2 TSRMLS_CC);
-	return Z_LVAL_P(result) < 0;
+	ZVAL_BOOL(result, Z_LVAL_P(result) != 0);
 }
 
-static zend_always_inline int fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
 	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_LVAL_P(op1) <= Z_LVAL_P(op2);
+			ZVAL_BOOL(result, Z_LVAL_P(op1) < Z_LVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return ((double)Z_LVAL_P(op1)) <= Z_DVAL_P(op2);
+			ZVAL_BOOL(result, (double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
+			return;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			return Z_DVAL_P(op1) <= Z_DVAL_P(op2);
+			ZVAL_BOOL(result, Z_DVAL_P(op1) < Z_DVAL_P(op2));
+			return;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			return Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2));
+			ZVAL_BOOL(result, Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
+			return;
 		}
 	}
 	compare_function(result, op1, op2 TSRMLS_CC);
-	return Z_LVAL_P(result) <= 0;
+	ZVAL_BOOL(result, Z_LVAL_P(result) < 0);
+}
+
+static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+	if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
+			ZVAL_BOOL(result, Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+			return;
+		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
+			ZVAL_BOOL(result, (double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
+			return;
+		}
+	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
+		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
+			ZVAL_BOOL(result, Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+			return;
+		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
+			ZVAL_BOOL(result, Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
+			return;
+		}
+	}
+	compare_function(result, op1, op2 TSRMLS_CC);
+	ZVAL_BOOL(result, Z_LVAL_P(result) <= 0);
+}
+
+static zend_always_inline void fast_is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+		ZVAL_BOOL(result, 0);
+		return;
+	}
+	is_identical_function(result, op1, op2 TSRMLS_CC);
+}
+
+static zend_always_inline void fast_is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+		ZVAL_BOOL(result, 1);
+		return;
+	}
+	is_identical_function(result, op1, op2 TSRMLS_CC);
+	ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
 }
 
 #define ZEND_TRY_BINARY_OBJECT_OPERATION(opcode)                                                  \
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index 423672d52d..3a339e792f 100644
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -204,27 +204,29 @@ struct _zend_ast_ref {
 /* regular data types */
 #define IS_UNDEF					0
 #define IS_NULL						1
-#define IS_BOOL						2
-#define IS_LONG						3
-#define IS_DOUBLE					4
-#define IS_STRING					5
-#define IS_ARRAY					6
-#define IS_OBJECT					7
-#define IS_RESOURCE					8
-#define IS_REFERENCE				9
+#define IS_FALSE					2
+#define IS_TRUE						3
+#define IS_LONG						4
+#define IS_DOUBLE					5
+#define IS_STRING					6
+#define IS_ARRAY					7
+#define IS_OBJECT					8
+#define IS_RESOURCE					9
+#define IS_REFERENCE				10
 
 /* constant expressions */
-#define IS_CONSTANT					10
-#define IS_CONSTANT_ARRAY			11
-#define IS_CONSTANT_AST				12
+#define IS_CONSTANT					11
+#define IS_CONSTANT_ARRAY			12
+#define IS_CONSTANT_AST				13
 
-/* type hinting */
-#define IS_CALLABLE					13
+/* fake types */
+#define _IS_BOOL					14
+#define IS_CALLABLE					15
 
 /* internal types */
-#define IS_INDIRECT             	14
-#define IS_STR_OFFSET				15
-#define IS_PTR						16
+#define IS_INDIRECT             	16
+#define IS_STR_OFFSET				17
+#define IS_PTR						18
 
 static inline zend_uchar zval_get_type(const zval* pz) {
 	return pz->u1.v.type;
@@ -369,9 +371,6 @@ static inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_ISREF(zval)				(Z_TYPE(zval) == IS_REFERENCE)
 #define Z_ISREF_P(zval_p)			Z_ISREF(*(zval_p))
 
-#define Z_BVAL(zval)				(zend_bool)(zval).value.lval
-#define Z_BVAL_P(zval_p)			Z_LVAL(*(zval_p))
-
 #define Z_LVAL(zval)				(zval).value.lval
 #define Z_LVAL_P(zval_p)			Z_LVAL(*(zval_p))
 
@@ -461,10 +460,17 @@ static inline zend_uchar zval_get_type(const zval* pz) {
 		Z_TYPE_INFO_P(z) = IS_NULL;		\
 	} while (0)
 
+#define ZVAL_FALSE(z) do {				\
+		Z_TYPE_INFO_P(z) = IS_FALSE;	\
+	} while (0)
+
+#define ZVAL_TRUE(z) do {				\
+		Z_TYPE_INFO_P(z) = IS_TRUE;		\
+	} while (0)
+
 #define ZVAL_BOOL(z, b) do {			\
-		zval *__z = (z);				\
-		Z_LVAL_P(__z) = ((b) != 0);		\
-		Z_TYPE_INFO_P(__z) = IS_BOOL;	\
+		Z_TYPE_INFO_P(z) =				\
+			(b) ? IS_TRUE : IS_FALSE;	\
 	} while (0)
 
 #define ZVAL_LONG(z, l) {				\
diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 5557c7beea..c05e404c06 100644
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -170,7 +170,8 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
 			}
 		case IS_LONG:
 		case IS_DOUBLE:
-		case IS_BOOL:
+		case IS_FALSE:
+		case IS_TRUE:
 		case IS_NULL:
 		default:
 			break;
@@ -201,7 +202,8 @@ ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
 			}
 		case IS_LONG:
 		case IS_DOUBLE:
-		case IS_BOOL:
+		case IS_FALSE:
+		case IS_TRUE:
 		case IS_NULL:
 		default:
 			break;
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 4c4115b761..739906f6c8 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -151,7 +151,7 @@ ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
 		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -167,10 +167,9 @@ ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
 		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -184,9 +183,9 @@ ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -200,9 +199,9 @@ ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -216,9 +215,9 @@ ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -232,9 +231,9 @@ ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -2107,8 +2106,8 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		FREE_OP1();
@@ -2137,8 +2136,8 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		FREE_OP1();
@@ -2167,8 +2166,8 @@ ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		FREE_OP1();
@@ -2201,8 +2200,8 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		FREE_OP1();
@@ -2231,8 +2230,8 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		FREE_OP1();
@@ -3448,9 +3447,9 @@ ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 GET_OP1_ZVAL_PTR(BP_VAR_R),
-				 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+	fast_equal_function(result,
+		 GET_OP1_ZVAL_PTR(BP_VAR_R),
+		 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -3709,7 +3708,6 @@ ZEND_VM_C_LABEL(add_again):
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				ZEND_VM_C_GOTO(num_index);
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index):
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -3725,6 +3723,12 @@ ZEND_VM_C_LABEL(str_index):
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				ZEND_VM_C_GOTO(str_index);
+			case IS_FALSE:
+				hval = 0;
+				ZEND_VM_C_GOTO(num_index);
+			case IS_TRUE:
+				hval = 1;
+				ZEND_VM_C_GOTO(num_index);
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				ZEND_VM_C_GOTO(add_again);
@@ -3797,7 +3801,7 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
 
 			ZVAL_NULL(result);
 			break;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
 			break;
 		case IS_LONG:
@@ -4067,10 +4071,9 @@ ZEND_VM_C_LABEL(offset_again):
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+ZEND_VM_C_LABEL(num_index_dim):
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -4078,7 +4081,7 @@ ZEND_VM_C_LABEL(offset_again):
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (OP2_TYPE != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(numeric_index_dim));
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -4089,7 +4092,7 @@ ZEND_VM_C_LABEL(offset_again):
 						zval_ptr_dtor(offset);
 					}
 					break;
-ZEND_VM_C_LABEL(num_index_dim):
+ZEND_VM_C_LABEL(numeric_index_dim):
 					zend_hash_index_del(ht, hval);
 					if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -4098,6 +4101,15 @@ ZEND_VM_C_LABEL(num_index_dim):
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					ZEND_VM_C_GOTO(num_index_dim);
+				case IS_TRUE:
+					hval = 1;
+					ZEND_VM_C_GOTO(num_index_dim);
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					ZEND_VM_C_GOTO(num_index_dim);
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					ZEND_VM_C_GOTO(offset_again);
@@ -4575,8 +4587,6 @@ ZEND_VM_C_LABEL(isset_again):
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				ZEND_VM_C_GOTO(num_index_prop);
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index_prop):
@@ -4594,6 +4604,15 @@ ZEND_VM_C_LABEL(str_index_prop):
 				str = STR_EMPTY_ALLOC();
 				ZEND_VM_C_GOTO(str_index_prop);
 				break;
+			case IS_FALSE:
+				hval = 0;
+				ZEND_VM_C_GOTO(num_index_prop);
+			case IS_TRUE:
+				hval = 0;
+				ZEND_VM_C_GOTO(num_index_prop);
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				ZEND_VM_C_GOTO(num_index_prop);
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				ZEND_VM_C_GOTO(isset_again);
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 41b907e802..ad7d4511d7 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2391,8 +2391,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -2421,8 +2421,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -2451,8 +2451,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2485,8 +2485,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2515,8 +2515,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	SAVE_OPLINE();
 	val = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2797,7 +2797,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 			ZVAL_NULL(result);
 			break;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
 			break;
 		case IS_LONG:
@@ -3381,7 +3381,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3397,10 +3397,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
 	CHECK_EXCEPTION();
@@ -3414,9 +3413,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		opline->op1.zv,
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -3430,9 +3429,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		opline->op1.zv,
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -3446,9 +3445,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		opline->op1.zv,
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -3462,9 +3461,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		opline->op1.zv,
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -3837,9 +3836,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 opline->op1.zv,
-				 opline->op2.zv TSRMLS_CC));
+	fast_equal_function(result,
+		 opline->op1.zv,
+		 opline->op2.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3982,7 +3981,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -3998,6 +3996,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -4505,7 +4509,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4521,10 +4525,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4538,9 +4541,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4554,9 +4557,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4570,9 +4573,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4586,9 +4589,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_O
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4793,9 +4796,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 opline->op1.zv,
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 opline->op1.zv,
+		 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4847,7 +4850,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -4863,6 +4865,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -5183,7 +5191,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -5199,10 +5207,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5216,9 +5223,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5232,9 +5239,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5248,9 +5255,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5264,9 +5271,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_O
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5617,9 +5624,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 opline->op1.zv,
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 opline->op1.zv,
+		 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -5671,7 +5678,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -5687,6 +5693,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -6337,7 +6349,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -6353,6 +6364,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -6827,7 +6844,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -6843,10 +6860,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
 	CHECK_EXCEPTION();
@@ -6860,9 +6876,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -6876,9 +6892,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -6892,9 +6908,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -6908,9 +6924,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7168,9 +7184,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 opline->op1.zv,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 opline->op1.zv,
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -7221,7 +7237,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -7237,6 +7252,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -7491,8 +7512,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		zval_dtor(free_op1.var);
@@ -7521,8 +7542,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		zval_dtor(free_op1.var);
@@ -7551,8 +7572,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_dtor(free_op1.var);
@@ -7585,8 +7606,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	SAVE_OPLINE();
 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_dtor(free_op1.var);
@@ -7615,8 +7636,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_dtor(free_op1.var);
@@ -7884,7 +7905,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 			ZVAL_NULL(result);
 			break;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
 			break;
 		case IS_LONG:
@@ -8518,7 +8539,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8534,10 +8555,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -8551,9 +8571,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -8567,9 +8587,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -8583,9 +8603,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -8599,9 +8619,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_O
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -8967,9 +8987,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 opline->op2.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -9020,7 +9040,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -9036,6 +9055,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -9507,7 +9532,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9523,10 +9548,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9540,9 +9564,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9556,9 +9580,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9572,9 +9596,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9588,9 +9612,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPC
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9795,9 +9819,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -9849,7 +9873,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -9865,6 +9888,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -10185,7 +10214,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10201,10 +10230,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10218,9 +10246,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10234,9 +10262,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10250,9 +10278,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10266,9 +10294,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPC
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10619,9 +10647,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10673,7 +10701,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -10689,6 +10716,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -11225,7 +11258,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -11241,6 +11273,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -11697,7 +11735,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -11713,10 +11751,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -11730,9 +11767,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -11746,9 +11783,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -11762,9 +11799,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -11778,9 +11815,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -11983,9 +12020,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -12036,7 +12073,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -12052,6 +12088,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -12530,8 +12572,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		zval_ptr_dtor_nogc(free_op1.var);
@@ -12560,8 +12602,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 		zval_ptr_dtor_nogc(free_op1.var);
@@ -12590,8 +12632,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_ptr_dtor_nogc(free_op1.var);
@@ -12624,8 +12666,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	SAVE_OPLINE();
 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_ptr_dtor_nogc(free_op1.var);
@@ -12654,8 +12696,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 		zval_ptr_dtor_nogc(free_op1.var);
@@ -13041,7 +13083,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 			ZVAL_NULL(result);
 			break;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
 			break;
 		case IS_LONG:
@@ -13789,7 +13831,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
@@ -13805,10 +13847,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -13822,9 +13863,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -13838,9 +13879,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -13854,9 +13895,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -13870,9 +13911,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_O
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -15235,9 +15276,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 opline->op2.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15380,7 +15421,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -15396,6 +15436,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -15542,10 +15588,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -15553,7 +15598,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CONST != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -15564,7 +15609,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -15573,6 +15618,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -15741,8 +15795,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -15760,6 +15812,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -16128,7 +16189,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
@@ -16144,10 +16205,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -16161,9 +16221,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -16177,9 +16237,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -16193,9 +16253,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -16209,9 +16269,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPC
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -17435,9 +17495,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -17489,7 +17549,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -17505,6 +17564,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -17579,10 +17644,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -17590,7 +17654,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_TMP_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -17601,7 +17665,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -17610,6 +17674,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -17699,8 +17772,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -17718,6 +17789,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -18088,7 +18168,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
@@ -18104,10 +18184,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -18121,9 +18200,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -18137,9 +18216,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -18153,9 +18232,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -18169,9 +18248,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPC
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -19605,9 +19684,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -19659,7 +19738,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -19675,6 +19753,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -19821,10 +19905,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -19832,7 +19915,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -19843,7 +19926,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -19852,6 +19935,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -20020,8 +20112,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -20039,6 +20129,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -21082,7 +21181,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -21098,6 +21196,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -21578,7 +21682,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
@@ -21594,10 +21698,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -21611,9 +21714,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -21627,9 +21730,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -21643,9 +21746,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -21659,9 +21762,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -22940,9 +23043,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22993,7 +23096,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -23009,6 +23111,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -23083,10 +23191,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -23094,7 +23201,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CV != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -23105,7 +23212,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -23114,6 +23221,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -23203,8 +23319,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -23222,6 +23336,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -24520,10 +24643,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -24531,7 +24653,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CONST != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -24542,7 +24664,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -24551,6 +24673,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -24640,8 +24771,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -24659,6 +24788,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -25781,10 +25919,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -25792,7 +25929,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_TMP_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -25803,7 +25940,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -25812,6 +25949,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -25901,8 +26047,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -25920,6 +26064,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -27044,10 +27197,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -27055,7 +27207,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -27066,7 +27218,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -27075,6 +27227,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -27164,8 +27325,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -27183,6 +27342,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -28816,10 +28984,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -28827,7 +28994,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CV != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -28838,7 +29005,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -28847,6 +29014,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -28936,8 +29112,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -28955,6 +29129,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -29460,8 +29643,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -29490,8 +29673,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		ret = Z_LVAL_P(val);
+	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		ret = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -29520,8 +29703,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29554,8 +29737,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29584,8 +29767,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	SAVE_OPLINE();
 	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-		retval = Z_LVAL_P(val);
+	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+		retval = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29944,7 +30127,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 			ZVAL_NULL(result);
 			break;
-		case IS_BOOL:
+		case _IS_BOOL:
 			ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
 			break;
 		case IS_LONG:
@@ -30549,7 +30732,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
@@ -30565,10 +30748,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
 	CHECK_EXCEPTION();
@@ -30582,9 +30764,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -30598,9 +30780,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -30614,9 +30796,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -30630,9 +30812,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		opline->op2.zv TSRMLS_CC));
+		opline->op2.zv TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -31879,9 +32061,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		 opline->op2.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -31932,7 +32114,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -31948,6 +32129,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -32094,10 +32281,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -32105,7 +32291,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CONST != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -32116,7 +32302,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -32125,6 +32311,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -32293,8 +32488,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -32312,6 +32505,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -32679,7 +32881,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -32695,10 +32897,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -32712,9 +32913,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -32728,9 +32929,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -32744,9 +32945,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -32760,9 +32961,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -33870,9 +34071,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -33924,7 +34125,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -33940,6 +34140,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -34014,10 +34220,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -34025,7 +34230,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_TMP_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -34036,7 +34241,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -34045,6 +34250,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -34134,8 +34348,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -34153,6 +34365,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -34522,7 +34743,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -34538,10 +34759,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -34555,9 +34775,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -34571,9 +34791,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -34587,9 +34807,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -34603,9 +34823,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCO
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -35922,9 +36142,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
@@ -35976,7 +36196,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -35992,6 +36211,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -36138,10 +36363,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -36149,7 +36373,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_VAR != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -36160,7 +36384,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -36169,6 +36393,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -36337,8 +36570,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -36356,6 +36587,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;
@@ -37283,7 +37523,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -37299,6 +37538,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -37760,7 +38005,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 
 
 	SAVE_OPLINE();
-	is_identical_function(EX_VAR(opline->result.var),
+	fast_is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -37776,10 +38021,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_identical_function(result,
+	fast_is_not_identical_function(result,
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
 	CHECK_EXCEPTION();
@@ -37793,9 +38037,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
+	fast_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -37809,9 +38053,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_not_equal_function(result,
+	fast_not_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -37825,9 +38069,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_function(result,
+	fast_is_smaller_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -37841,9 +38085,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+	fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39005,9 +39249,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	ZVAL_BOOL(result, fast_equal_function(result,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+	fast_equal_function(result,
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -39058,7 +39302,6 @@ add_again:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index;
 			case IS_LONG:
-			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
 				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -39074,6 +39317,12 @@ str_index:
 			case IS_NULL:
 				str = STR_EMPTY_ALLOC();
 				goto str_index;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index;
+			case IS_TRUE:
+				hval = 1;
+				goto num_index;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto add_again;
@@ -39148,10 +39397,9 @@ offset_again:
 					hval = zend_dval_to_lval(Z_DVAL_P(offset));
 					zend_hash_index_del(ht, hval);
 					break;
-				case IS_RESOURCE:
-				case IS_BOOL:
 				case IS_LONG:
 					hval = Z_LVAL_P(offset);
+num_index_dim:
 					zend_hash_index_del(ht, hval);
 					break;
 				case IS_STRING:
@@ -39159,7 +39407,7 @@ offset_again:
 						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
 					}
 					if (IS_CV != IS_CONST) {
-						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
 					}
 					if (ht == &EG(symbol_table).ht) {
 						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -39170,7 +39418,7 @@ offset_again:
 						zval_ptr_dtor(offset);
 					}
 					break;
-num_index_dim:
+numeric_index_dim:
 					zend_hash_index_del(ht, hval);
 					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
 						zval_ptr_dtor(offset);
@@ -39179,6 +39427,15 @@ num_index_dim:
 				case IS_NULL:
 					zend_hash_del(ht, STR_EMPTY_ALLOC());
 					break;
+				case IS_FALSE:
+					hval = 0;
+					goto num_index_dim;
+				case IS_TRUE:
+					hval = 1;
+					goto num_index_dim;
+				case IS_RESOURCE:
+					hval = Z_RES_HANDLE_P(offset);
+					goto num_index_dim;
 				case IS_REFERENCE:
 					offset = Z_REFVAL_P(offset);
 					goto offset_again;
@@ -39268,8 +39525,6 @@ isset_again:
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
 				goto num_index_prop;
-			case IS_RESOURCE:
-			case IS_BOOL:
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -39287,6 +39542,15 @@ str_index_prop:
 				str = STR_EMPTY_ALLOC();
 				goto str_index_prop;
 				break;
+			case IS_FALSE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_TRUE:
+				hval = 0;
+				goto num_index_prop;
+			case IS_RESOURCE:
+				hval = Z_RES_HANDLE_P(offset);
+				goto num_index_prop;
 			case IS_REFERENCE:
 				offset = Z_REFVAL_P(offset);
 				goto isset_again;