missing, apparently

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 24d6aadd69c4a66ac5be3a0b36eba98653086e1e..c0378dcbc06b894b6d8958ced4307005dfe92b8b 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1108,7 +1108,7 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
        if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
                if (EX(delayed_exception)) {
                        zend_exception_set_previous(EG(exception), EX(delayed_exception) TSRMLS_CC);
-               } 
+               }
                EX(delayed_exception) = EG(exception);
                EG(exception) = NULL;
                EX(fast_ret) = NULL;
@@ -1243,7 +1243,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        } else {
-               
+
                zval *class_name = opline->op2.zv;
 
                if (IS_CONST == IS_CONST) {
@@ -1294,7 +1294,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
        } else {
                char *function_name_strval, *lcname;
                int function_name_strlen;
-               
+
 
                SAVE_OPLINE();
                function_name = opline->op2.zv;
@@ -1940,7 +1940,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        } else {
-               
+
                zval *class_name = NULL;
 
                if (IS_UNUSED == IS_CONST) {
@@ -1979,7 +1979,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
                CHECK_EXCEPTION();
                ZEND_VM_NEXT_OPCODE();
        } else {
-               
+
                zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                if (IS_CV == IS_CONST) {
@@ -2030,7 +2030,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
        } else {
                char *function_name_strval, *lcname;
                int function_name_strlen;
-               
+
 
                SAVE_OPLINE();
                function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
@@ -2155,7 +2155,7 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_not_function(&EX_T(opline->result.var).tmp_var,
@@ -2168,7 +2168,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_not_function(&EX_T(opline->result.var).tmp_var,
@@ -2181,7 +2181,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *z;
 
        SAVE_OPLINE();
@@ -2207,7 +2207,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int ret;
 
@@ -2237,7 +2237,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int ret;
 
@@ -2267,7 +2267,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -2301,7 +2301,7 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -2332,7 +2332,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -2363,7 +2363,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *fname = opline->op1.zv;
        call_slot *call = EX(call_slots) + opline->op2.num;
 
@@ -2388,7 +2388,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
        zval *retval_ptr;
-       
+
 
        SAVE_OPLINE();
        retval_ptr = opline->op1.zv;
@@ -2432,12 +2432,12 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
        USE_OPLINE
        zval *retval_ptr;
        zval **retval_ptr_ptr;
-       
+
 
        SAVE_OPLINE();
 
        do {
-               if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR || 
+               if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR ||
                    (IS_CONST == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -2503,7 +2503,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        USE_OPLINE
        zval *value;
        zval *exception;
-       
+
 
        SAVE_OPLINE();
        value = opline->op1.zv;
@@ -2541,7 +2541,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        {
                zval *valptr;
                zval *value;
-               
+
 
                value = opline->op1.zv;
 
@@ -2560,7 +2560,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *retval = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -2574,7 +2574,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *obj;
        zend_class_entry *ce;
        zend_function *clone;
@@ -2640,7 +2640,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr;
        zval *result = &EX_T(opline->result.var).tmp_var;
 
@@ -2700,7 +2700,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 {
        USE_OPLINE
        zend_op_array *new_op_array=NULL;
-       
+
        zval *inc_filename;
        zval *tmp_inc_filename = NULL;
        zend_bool failure_retval=0;
@@ -2832,7 +2832,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *array_ptr, **array_ptr_ptr;
        HashTable *fe_ht;
        zend_object_iterator *iter = NULL;
@@ -2891,7 +2891,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
                                }
                        }
                } else if (IS_CONST == IS_CONST ||
-                          (IS_CONST == IS_CV && 
+                          (IS_CONST == IS_CV &&
                            !Z_ISREF_P(array_ptr) &&
                            Z_REFCOUNT_P(array_ptr) > 1) ||
                           (IS_CONST == IS_VAR &&
@@ -2998,7 +2998,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
        SAVE_OPLINE();
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *ptr = opline->op1.zv;
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -3016,7 +3016,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
 
        SAVE_OPLINE();
@@ -3041,7 +3041,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value, *ret;
 
        SAVE_OPLINE();
@@ -3075,7 +3075,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
 
        SAVE_OPLINE();
@@ -3093,7 +3093,7 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value, *ret;
 
        SAVE_OPLINE();
@@ -3120,7 +3120,7 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_add_function(&EX_T(opline->result.var).tmp_var,
@@ -3135,7 +3135,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_sub_function(&EX_T(opline->result.var).tmp_var,
@@ -3150,7 +3150,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mul_function(&EX_T(opline->result.var).tmp_var,
@@ -3165,7 +3165,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_div_function(&EX_T(opline->result.var).tmp_var,
@@ -3180,7 +3180,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mod_function(&EX_T(opline->result.var).tmp_var,
@@ -3195,7 +3195,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_left_function(&EX_T(opline->result.var).tmp_var,
@@ -3210,7 +3210,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_right_function(&EX_T(opline->result.var).tmp_var,
@@ -3225,7 +3225,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        concat_function(&EX_T(opline->result.var).tmp_var,
@@ -3240,7 +3240,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_identical_function(&EX_T(opline->result.var).tmp_var,
@@ -3255,7 +3255,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -3272,7 +3272,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -3288,7 +3288,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -3304,7 +3304,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -3320,7 +3320,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -3336,7 +3336,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_or_function(&EX_T(opline->result.var).tmp_var,
@@ -3351,7 +3351,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_and_function(&EX_T(opline->result.var).tmp_var,
@@ -3366,7 +3366,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -3381,7 +3381,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -3449,7 +3449,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
                if (IS_CONST == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -3558,7 +3558,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -3575,7 +3575,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -3585,7 +3585,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
                PZVAL_LOCK(&EG(uninitialized_zval));
                EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
        } else {
-               
+
                zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
                PZVAL_LOCK(value);
@@ -3641,7 +3641,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
        } else if (IS_CONST != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_CONST == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -3722,7 +3722,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_equal_function(&EX_T(opline->result.var).tmp_var,
@@ -3832,7 +3832,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -3867,7 +3867,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
        }
 
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *offset = opline->op2.zv;
                ulong hval;
 
@@ -3929,7 +3929,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CONST == IS_CV &&
@@ -4025,7 +4025,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = opline->op1.zv;
 
                if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -4090,7 +4090,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *name;
        zval *val;
        zend_constant c;
@@ -4150,7 +4150,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 
        /* Set the new yielded value */
        if (IS_CONST != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -4228,7 +4228,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 
        /* Set the new yielded key */
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *key = opline->op2.zv;
 
                /* Consts, temporary variables and references need copying */
@@ -4720,7 +4720,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -4835,7 +4835,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded value */
        if (IS_CONST != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -5303,7 +5303,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
                if (IS_CONST == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -5567,7 +5567,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -5664,7 +5664,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CONST == IS_CV &&
@@ -5760,7 +5760,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = opline->op1.zv;
 
                if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -5845,7 +5845,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded value */
        if (IS_CONST != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -6038,7 +6038,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
                if (IS_CONST == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -6189,7 +6189,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
        } else if (IS_UNUSED != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_UNUSED == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -6270,7 +6270,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -6305,7 +6305,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
        }
 
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *offset = NULL;
                ulong hval;
 
@@ -6367,7 +6367,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CONST == IS_CV &&
@@ -6463,7 +6463,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = opline->op1.zv;
 
                if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -6566,7 +6566,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 
        /* Set the new yielded value */
        if (IS_CONST != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -6644,7 +6644,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 
        /* Set the new yielded key */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *key = NULL;
 
                /* Consts, temporary variables and references need copying */
@@ -6705,7 +6705,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_add_function(&EX_T(opline->result.var).tmp_var,
@@ -6720,7 +6720,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_sub_function(&EX_T(opline->result.var).tmp_var,
@@ -6735,7 +6735,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mul_function(&EX_T(opline->result.var).tmp_var,
@@ -6750,7 +6750,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_div_function(&EX_T(opline->result.var).tmp_var,
@@ -6765,7 +6765,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mod_function(&EX_T(opline->result.var).tmp_var,
@@ -6780,7 +6780,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_left_function(&EX_T(opline->result.var).tmp_var,
@@ -6795,7 +6795,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_right_function(&EX_T(opline->result.var).tmp_var,
@@ -6810,7 +6810,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        concat_function(&EX_T(opline->result.var).tmp_var,
@@ -6825,7 +6825,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_identical_function(&EX_T(opline->result.var).tmp_var,
@@ -6840,7 +6840,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -6857,7 +6857,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -6873,7 +6873,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -6889,7 +6889,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -6905,7 +6905,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -6921,7 +6921,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_or_function(&EX_T(opline->result.var).tmp_var,
@@ -6936,7 +6936,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_and_function(&EX_T(opline->result.var).tmp_var,
@@ -6951,7 +6951,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -6966,7 +6966,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -6981,7 +6981,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -7040,7 +7040,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
        } else if (IS_CV != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_CV == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -7181,7 +7181,7 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_equal_function(&EX_T(opline->result.var).tmp_var,
@@ -7195,7 +7195,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -7230,7 +7230,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
        }
 
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                ulong hval;
 
@@ -7310,7 +7310,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
        /* Set the new yielded value */
        if (IS_CONST != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -7388,7 +7388,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                /* Consts, temporary variables and references need copying */
@@ -7722,7 +7722,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR || 
+               if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR ||
                    (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -8177,7 +8177,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
                                }
                        }
                } else if (IS_TMP_VAR == IS_CONST ||
-                          (IS_TMP_VAR == IS_CV && 
+                          (IS_TMP_VAR == IS_CV &&
                            !Z_ISREF_P(array_ptr) &&
                            Z_REFCOUNT_P(array_ptr) > 1) ||
                           (IS_TMP_VAR == IS_VAR &&
@@ -8787,7 +8787,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
                if (IS_TMP_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -8923,7 +8923,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
                PZVAL_LOCK(&EG(uninitialized_zval));
                EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
        } else {
-               
+
                zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
                PZVAL_LOCK(value);
@@ -9111,7 +9111,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
        }
 
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *offset = opline->op2.zv;
                ulong hval;
 
@@ -9432,7 +9432,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded key */
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *key = opline->op2.zv;
 
                /* Consts, temporary variables and references need copying */
@@ -10509,7 +10509,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
                if (IS_TMP_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -11246,7 +11246,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
                if (IS_TMP_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -11390,7 +11390,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
        }
 
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *offset = NULL;
                ulong hval;
 
@@ -11711,7 +11711,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 
        /* Set the new yielded key */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *key = NULL;
 
                /* Consts, temporary variables and references need copying */
@@ -12065,7 +12065,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *str = &EX_T(opline->result.var).tmp_var;
        zval *var;
        zval var_copy;
@@ -12237,7 +12237,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
        }
 
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                ulong hval;
 
@@ -12395,7 +12395,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                /* Consts, temporary variables and references need copying */
@@ -12909,7 +12909,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
        SAVE_OPLINE();
 
        do {
-               if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR || 
+               if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR ||
                    (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -13474,7 +13474,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
                                }
                        }
                } else if (IS_VAR == IS_CONST ||
-                          (IS_VAR == IS_CV && 
+                          (IS_VAR == IS_CV &&
                            !Z_ISREF_P(array_ptr) &&
                            Z_REFCOUNT_P(array_ptr) > 1) ||
                           (IS_VAR == IS_VAR &&
@@ -13577,7 +13577,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *array = EX_T(opline->op1.var).fe.ptr;
        zval **value;
        HashTable *fe_ht;
@@ -14645,7 +14645,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
                if (IS_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -14919,7 +14919,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
        USE_OPLINE
        zend_free_op free_op1;
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -15042,7 +15042,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        USE_OPLINE
        zend_free_op free_op1;
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -15202,7 +15202,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = opline->op2.zv;
 
                if (0) {
@@ -15449,7 +15449,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
        } else if (IS_CONST != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_CONST == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -15675,7 +15675,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
        }
 
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *offset = opline->op2.zv;
                ulong hval;
 
@@ -16281,7 +16281,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded key */
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *key = opline->op2.zv;
 
                /* Consts, temporary variables and references need copying */
@@ -19197,7 +19197,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
                if (IS_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -21162,7 +21162,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
                if (IS_VAR == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -21371,7 +21371,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = NULL;
 
                if (0) {
@@ -21483,7 +21483,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
        } else if (IS_UNUSED != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_UNUSED == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -21599,7 +21599,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
        }
 
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *offset = NULL;
                ulong hval;
 
@@ -21942,7 +21942,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 
        /* Set the new yielded key */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *key = NULL;
 
                /* Consts, temporary variables and references need copying */
@@ -22902,7 +22902,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
        USE_OPLINE
        zend_free_op free_op1;
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -23025,7 +23025,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
        USE_OPLINE
        zend_free_op free_op1;
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -23185,7 +23185,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                if (0) {
@@ -23485,7 +23485,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
        } else if (IS_CV != IS_UNUSED) {
                char *function_name_strval = NULL;
                int function_name_strlen = 0;
-               
+
 
                if (IS_CV == IS_CONST) {
                        function_name_strval = Z_STRVAL_P(opline->op2.zv);
@@ -23615,7 +23615,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
        }
 
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                ulong hval;
 
@@ -24058,7 +24058,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                /* Consts, temporary variables and references need copying */
@@ -24119,7 +24119,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *obj;
        zend_class_entry *ce;
        zend_function *clone;
@@ -24189,7 +24189,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
        SAVE_OPLINE();
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *ptr = NULL;
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -24458,7 +24458,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -24562,7 +24562,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -24664,9 +24664,9 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CONST(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -24785,9 +24785,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -24905,7 +24905,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *property_name;
 
@@ -24984,7 +24984,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-       
+
        call_slot *call = EX(call_slots) + opline->result.num;
 
        SAVE_OPLINE();
@@ -25170,7 +25170,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
        ulong hval;
@@ -25265,7 +25265,7 @@ num_index_dim:
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
 
@@ -25305,7 +25305,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zval **value = NULL;
        int result = 0;
@@ -25470,7 +25470,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 
        /* Set the new yielded value */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -25548,7 +25548,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 
        /* Set the new yielded key */
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *key = opline->op2.zv;
 
                /* Consts, temporary variables and references need copying */
@@ -26067,7 +26067,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -26188,7 +26188,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -26777,7 +26777,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
 
        /* Set the new yielded value */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -27374,7 +27374,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -27495,7 +27495,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -28084,7 +28084,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
 
        /* Set the new yielded value */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -28509,7 +28509,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 
        /* Set the new yielded value */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -28587,7 +28587,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 
        /* Set the new yielded key */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *key = NULL;
 
                /* Consts, temporary variables and references need copying */
@@ -28899,7 +28899,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -29003,7 +29003,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -29105,9 +29105,9 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -29226,9 +29226,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -29346,7 +29346,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *property_name;
 
@@ -29376,7 +29376,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *str = &EX_T(opline->result.var).tmp_var;
        zval *var;
        zval var_copy;
@@ -29423,7 +29423,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-       
+
        call_slot *call = EX(call_slots) + opline->result.num;
 
        SAVE_OPLINE();
@@ -29513,7 +29513,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
        ulong hval;
@@ -29608,7 +29608,7 @@ num_index_dim:
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
 
@@ -29648,7 +29648,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zval **value = NULL;
        int result = 0;
@@ -29813,7 +29813,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded value */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -29891,7 +29891,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                /* Consts, temporary variables and references need copying */
@@ -29952,7 +29952,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_not_function(&EX_T(opline->result.var).tmp_var,
@@ -29965,7 +29965,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_not_function(&EX_T(opline->result.var).tmp_var,
@@ -29978,7 +29978,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **var_ptr;
 
        SAVE_OPLINE();
@@ -30024,7 +30024,7 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **var_ptr;
 
        SAVE_OPLINE();
@@ -30070,7 +30070,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **var_ptr, *retval;
 
        SAVE_OPLINE();
@@ -30112,7 +30112,7 @@ static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **var_ptr, *retval;
 
        SAVE_OPLINE();
@@ -30154,7 +30154,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *z;
 
        SAVE_OPLINE();
@@ -30180,7 +30180,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int ret;
 
@@ -30210,7 +30210,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int ret;
 
@@ -30240,7 +30240,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -30274,7 +30274,7 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -30305,7 +30305,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *val;
        int retval;
 
@@ -30337,7 +30337,7 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
        zval *retval_ptr;
-       
+
 
        SAVE_OPLINE();
        retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
@@ -30381,12 +30381,12 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
        USE_OPLINE
        zval *retval_ptr;
        zval **retval_ptr_ptr;
-       
+
 
        SAVE_OPLINE();
 
        do {
-               if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR || 
+               if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR ||
                    (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) {
                        /* Not supposed to happen, but we'll allow it */
                        zend_error(E_NOTICE, "Only variable references should be returned by reference");
@@ -30452,7 +30452,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        USE_OPLINE
        zval *value;
        zval *exception;
-       
+
 
        SAVE_OPLINE();
        value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
@@ -30482,7 +30482,7 @@ static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARG
 {
        USE_OPLINE
        zval *varptr;
-       
+
        varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
        if (varptr == &EG(uninitialized_zval)) {
@@ -30514,7 +30514,7 @@ static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *varptr;
 
        SAVE_OPLINE();
@@ -30559,7 +30559,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **varptr_ptr;
        zval *varptr;
 
@@ -30607,7 +30607,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *retval = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -30621,7 +30621,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *obj;
        zend_class_entry *ce;
        zend_function *clone;
@@ -30687,7 +30687,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr;
        zval *result = &EX_T(opline->result.var).tmp_var;
 
@@ -30747,7 +30747,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
        zend_op_array *new_op_array=NULL;
-       
+
        zval *inc_filename;
        zval *tmp_inc_filename = NULL;
        zend_bool failure_retval=0;
@@ -30879,7 +30879,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *array_ptr, **array_ptr_ptr;
        HashTable *fe_ht;
        zend_object_iterator *iter = NULL;
@@ -30938,7 +30938,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
                                }
                        }
                } else if (IS_CV == IS_CONST ||
-                          (IS_CV == IS_CV && 
+                          (IS_CV == IS_CV &&
                            !Z_ISREF_P(array_ptr) &&
                            Z_REFCOUNT_P(array_ptr) > 1) ||
                           (IS_CV == IS_VAR &&
@@ -31045,7 +31045,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
        SAVE_OPLINE();
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
                if (Z_TYPE_P(ptr) == IS_LONG) {
@@ -31063,7 +31063,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
 
        SAVE_OPLINE();
@@ -31088,7 +31088,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value, *ret;
 
        SAVE_OPLINE();
@@ -31122,7 +31122,7 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
 
        SAVE_OPLINE();
@@ -31140,7 +31140,7 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value, *ret;
 
        SAVE_OPLINE();
@@ -31167,7 +31167,7 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr;
        zend_bool result;
 
@@ -31188,7 +31188,7 @@ static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_add_function(&EX_T(opline->result.var).tmp_var,
@@ -31203,7 +31203,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_sub_function(&EX_T(opline->result.var).tmp_var,
@@ -31218,7 +31218,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mul_function(&EX_T(opline->result.var).tmp_var,
@@ -31233,7 +31233,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_div_function(&EX_T(opline->result.var).tmp_var,
@@ -31248,7 +31248,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mod_function(&EX_T(opline->result.var).tmp_var,
@@ -31263,7 +31263,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_left_function(&EX_T(opline->result.var).tmp_var,
@@ -31278,7 +31278,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_right_function(&EX_T(opline->result.var).tmp_var,
@@ -31293,7 +31293,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        concat_function(&EX_T(opline->result.var).tmp_var,
@@ -31308,7 +31308,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_identical_function(&EX_T(opline->result.var).tmp_var,
@@ -31323,7 +31323,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -31340,7 +31340,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -31356,7 +31356,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -31372,7 +31372,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -31388,7 +31388,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -31404,7 +31404,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_or_function(&EX_T(opline->result.var).tmp_var,
@@ -31419,7 +31419,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_and_function(&EX_T(opline->result.var).tmp_var,
@@ -31434,7 +31434,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -31449,7 +31449,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -31715,7 +31715,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -31819,7 +31819,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -31974,7 +31974,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
                if (IS_CV == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -32083,7 +32083,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -32155,7 +32155,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -32245,9 +32245,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -32366,9 +32366,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -32486,7 +32486,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *property_name;
 
@@ -32516,7 +32516,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
 
        SAVE_OPLINE();
@@ -32526,7 +32526,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = opline->op2.zv;
 
                if (0) {
@@ -32596,7 +32596,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
        zval **variable_ptr_ptr;
 
@@ -32652,7 +32652,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-       
+
        call_slot *call = EX(call_slots) + opline->result.num;
 
        SAVE_OPLINE();
@@ -32728,7 +32728,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_equal_function(&EX_T(opline->result.var).tmp_var,
@@ -32742,7 +32742,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -32777,7 +32777,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
        }
 
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *offset = opline->op2.zv;
                ulong hval;
 
@@ -32839,7 +32839,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CV == IS_CV &&
@@ -32915,7 +32915,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
        ulong hval;
@@ -33010,7 +33010,7 @@ num_index_dim:
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
 
@@ -33070,7 +33070,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
                if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -33135,7 +33135,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zval **value = NULL;
        int result = 0;
@@ -33300,7 +33300,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
        /* Set the new yielded value */
        if (IS_CV != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -33378,7 +33378,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
        /* Set the new yielded key */
        if (IS_CONST != IS_UNUSED) {
-               
+
                zval *key = opline->op2.zv;
 
                /* Consts, temporary variables and references need copying */
@@ -34335,7 +34335,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -34456,7 +34456,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -34606,7 +34606,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
 
        SAVE_OPLINE();
@@ -34835,7 +34835,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -35230,7 +35230,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
        /* Set the new yielded value */
        if (IS_CV != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -36156,7 +36156,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
                if (IS_CV == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -36427,7 +36427,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -36548,7 +36548,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zend_free_op free_op2;
        zval *offset;
@@ -36698,7 +36698,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
 
        SAVE_OPLINE();
@@ -36981,7 +36981,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -37078,7 +37078,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CV == IS_CV &&
@@ -37309,7 +37309,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
                if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -37539,7 +37539,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
        /* Set the new yielded value */
        if (IS_CV != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -37983,7 +37983,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
                if (IS_CV == IS_CONST) {
                        hash_value = Z_HASH_P(varname);
                } else {
-                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));        
+                       hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
                }
 
                if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
@@ -38181,7 +38181,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
 
        SAVE_OPLINE();
@@ -38191,7 +38191,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = NULL;
 
                if (0) {
@@ -38261,7 +38261,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -38296,7 +38296,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
        }
 
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *offset = NULL;
                ulong hval;
 
@@ -38358,7 +38358,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
        USE_OPLINE
        zval tmp, *varname;
        HashTable *target_symbol_table;
-       
+
 
        SAVE_OPLINE();
        if (IS_CV == IS_CV &&
@@ -38454,7 +38454,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
                }
        } else {
                HashTable *target_symbol_table;
-               
+
                zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
                if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
@@ -38539,7 +38539,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded value */
        if (IS_CV != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -38617,7 +38617,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 
        /* Set the new yielded key */
        if (IS_UNUSED != IS_UNUSED) {
-               
+
                zval *key = NULL;
 
                /* Consts, temporary variables and references need copying */
@@ -38678,7 +38678,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_add_function(&EX_T(opline->result.var).tmp_var,
@@ -38693,7 +38693,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_sub_function(&EX_T(opline->result.var).tmp_var,
@@ -38708,7 +38708,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mul_function(&EX_T(opline->result.var).tmp_var,
@@ -38723,7 +38723,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_div_function(&EX_T(opline->result.var).tmp_var,
@@ -38738,7 +38738,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        fast_mod_function(&EX_T(opline->result.var).tmp_var,
@@ -38753,7 +38753,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_left_function(&EX_T(opline->result.var).tmp_var,
@@ -38768,7 +38768,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        shift_right_function(&EX_T(opline->result.var).tmp_var,
@@ -38783,7 +38783,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        concat_function(&EX_T(opline->result.var).tmp_var,
@@ -38798,7 +38798,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_identical_function(&EX_T(opline->result.var).tmp_var,
@@ -38813,7 +38813,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -38830,7 +38830,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -38846,7 +38846,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -38862,7 +38862,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -38878,7 +38878,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *result = &EX_T(opline->result.var).tmp_var;
 
        SAVE_OPLINE();
@@ -38894,7 +38894,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_or_function(&EX_T(opline->result.var).tmp_var,
@@ -38909,7 +38909,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_and_function(&EX_T(opline->result.var).tmp_var,
@@ -38924,7 +38924,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -38939,7 +38939,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        boolean_xor_function(&EX_T(opline->result.var).tmp_var,
@@ -39205,7 +39205,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -39309,7 +39309,7 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *object;
        zval *property;
@@ -39411,7 +39411,7 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -39483,7 +39483,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
 
        SAVE_OPLINE();
@@ -39573,9 +39573,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -39694,9 +39694,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
-       
+
        zval *offset;
 
        SAVE_OPLINE();
@@ -39814,7 +39814,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
        zval *property_name;
 
@@ -39844,7 +39844,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **object_ptr;
 
        SAVE_OPLINE();
@@ -39854,7 +39854,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
        if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
-               
+
                zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                if (0) {
@@ -39924,7 +39924,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *value;
        zval **variable_ptr_ptr;
 
@@ -40032,7 +40032,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
        zval *function_name;
        char *function_name_strval;
        int function_name_strlen;
-       
+
        call_slot *call = EX(call_slots) + opline->result.num;
 
        SAVE_OPLINE();
@@ -40108,7 +40108,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
 
        SAVE_OPLINE();
        is_equal_function(&EX_T(opline->result.var).tmp_var,
@@ -40122,7 +40122,7 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *expr_ptr;
 
        SAVE_OPLINE();
@@ -40157,7 +40157,7 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
        }
 
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
                ulong hval;
 
@@ -40217,7 +40217,7 @@ static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
        ulong hval;
@@ -40312,7 +40312,7 @@ num_index_dim:
 static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval **container;
        zval *offset;
 
@@ -40352,7 +40352,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       
+
        zval *container;
        zval **value = NULL;
        int result = 0;
@@ -40517,7 +40517,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
        /* Set the new yielded value */
        if (IS_CV != IS_UNUSED) {
-               
+
 
                if (EX(op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) {
                        /* Constants and temporary variables aren't yieldable by reference,
@@ -40595,7 +40595,7 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
        /* Set the new yielded key */
        if (IS_CV != IS_UNUSED) {
-               
+
                zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                /* Consts, temporary variables and references need copying */

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
new file mode 100644 (file)
index 0000000..d334e45
--- /dev/null
+++ b/Zend/zend_vm_opcodes.h
@@ -0,0 +1,174 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   |          Dmitry Stogov <dmitry@zend.com>                             |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_VM_OPCODES_H
+#define ZEND_VM_OPCODES_H
+
+ZEND_API const char *zend_get_opcode_name(zend_uchar opcode);
+
+#define ZEND_NOP                               0
+#define ZEND_ADD                               1
+#define ZEND_SUB                               2
+#define ZEND_MUL                               3
+#define ZEND_DIV                               4
+#define ZEND_MOD                               5
+#define ZEND_SL                                6
+#define ZEND_SR                                7
+#define ZEND_CONCAT                            8
+#define ZEND_BW_OR                             9
+#define ZEND_BW_AND                           10
+#define ZEND_BW_XOR                           11
+#define ZEND_BW_NOT                           12
+#define ZEND_BOOL_NOT                         13
+#define ZEND_BOOL_XOR                         14
+#define ZEND_IS_IDENTICAL                     15
+#define ZEND_IS_NOT_IDENTICAL                 16
+#define ZEND_IS_EQUAL                         17
+#define ZEND_IS_NOT_EQUAL                     18
+#define ZEND_IS_SMALLER                       19
+#define ZEND_IS_SMALLER_OR_EQUAL              20
+#define ZEND_CAST                             21
+#define ZEND_QM_ASSIGN                        22
+#define ZEND_ASSIGN_ADD                       23
+#define ZEND_ASSIGN_SUB                       24
+#define ZEND_ASSIGN_MUL                       25
+#define ZEND_ASSIGN_DIV                       26
+#define ZEND_ASSIGN_MOD                       27
+#define ZEND_ASSIGN_SL                        28
+#define ZEND_ASSIGN_SR                        29
+#define ZEND_ASSIGN_CONCAT                    30
+#define ZEND_ASSIGN_BW_OR                     31
+#define ZEND_ASSIGN_BW_AND                    32
+#define ZEND_ASSIGN_BW_XOR                    33
+#define ZEND_PRE_INC                          34
+#define ZEND_PRE_DEC                          35
+#define ZEND_POST_INC                         36
+#define ZEND_POST_DEC                         37
+#define ZEND_ASSIGN                           38
+#define ZEND_ASSIGN_REF                       39
+#define ZEND_ECHO                             40
+#define ZEND_PRINT                            41
+#define ZEND_JMP                              42
+#define ZEND_JMPZ                             43
+#define ZEND_JMPNZ                            44
+#define ZEND_JMPZNZ                           45
+#define ZEND_JMPZ_EX                          46
+#define ZEND_JMPNZ_EX                         47
+#define ZEND_CASE                             48
+#define ZEND_SWITCH_FREE                      49
+#define ZEND_BRK                              50
+#define ZEND_CONT                             51
+#define ZEND_BOOL                             52
+#define ZEND_INIT_STRING                      53
+#define ZEND_ADD_CHAR                         54
+#define ZEND_ADD_STRING                       55
+#define ZEND_ADD_VAR                          56
+#define ZEND_BEGIN_SILENCE                    57
+#define ZEND_END_SILENCE                      58
+#define ZEND_INIT_FCALL_BY_NAME               59
+#define ZEND_DO_FCALL                         60
+#define ZEND_DO_FCALL_BY_NAME                 61
+#define ZEND_RETURN                           62
+#define ZEND_RECV                             63
+#define ZEND_RECV_INIT                        64
+#define ZEND_SEND_VAL                         65
+#define ZEND_SEND_VAR                         66
+#define ZEND_SEND_REF                         67
+#define ZEND_NEW                              68
+#define ZEND_INIT_NS_FCALL_BY_NAME            69
+#define ZEND_FREE                             70
+#define ZEND_INIT_ARRAY                       71
+#define ZEND_ADD_ARRAY_ELEMENT                72
+#define ZEND_INCLUDE_OR_EVAL                  73
+#define ZEND_UNSET_VAR                        74
+#define ZEND_UNSET_DIM                        75
+#define ZEND_UNSET_OBJ                        76
+#define ZEND_FE_RESET                         77
+#define ZEND_FE_FETCH                         78
+#define ZEND_EXIT                             79
+#define ZEND_FETCH_R                          80
+#define ZEND_FETCH_DIM_R                      81
+#define ZEND_FETCH_OBJ_R                      82
+#define ZEND_FETCH_W                          83
+#define ZEND_FETCH_DIM_W                      84
+#define ZEND_FETCH_OBJ_W                      85
+#define ZEND_FETCH_RW                         86
+#define ZEND_FETCH_DIM_RW                     87
+#define ZEND_FETCH_OBJ_RW                     88
+#define ZEND_FETCH_IS                         89
+#define ZEND_FETCH_DIM_IS                     90
+#define ZEND_FETCH_OBJ_IS                     91
+#define ZEND_FETCH_FUNC_ARG                   92
+#define ZEND_FETCH_DIM_FUNC_ARG               93
+#define ZEND_FETCH_OBJ_FUNC_ARG               94
+#define ZEND_FETCH_UNSET                      95
+#define ZEND_FETCH_DIM_UNSET                  96
+#define ZEND_FETCH_OBJ_UNSET                  97
+#define ZEND_FETCH_DIM_TMP_VAR                98
+#define ZEND_FETCH_CONSTANT                   99
+#define ZEND_GOTO                            100
+#define ZEND_EXT_STMT                        101
+#define ZEND_EXT_FCALL_BEGIN                 102
+#define ZEND_EXT_FCALL_END                   103
+#define ZEND_EXT_NOP                         104
+#define ZEND_TICKS                           105
+#define ZEND_SEND_VAR_NO_REF                 106
+#define ZEND_CATCH                           107
+#define ZEND_THROW                           108
+#define ZEND_FETCH_CLASS                     109
+#define ZEND_CLONE                           110
+#define ZEND_RETURN_BY_REF                   111
+#define ZEND_INIT_METHOD_CALL                112
+#define ZEND_INIT_STATIC_METHOD_CALL         113
+#define ZEND_ISSET_ISEMPTY_VAR               114
+#define ZEND_ISSET_ISEMPTY_DIM_OBJ           115
+#define ZEND_PRE_INC_OBJ                     132
+#define ZEND_PRE_DEC_OBJ                     133
+#define ZEND_POST_INC_OBJ                    134
+#define ZEND_POST_DEC_OBJ                    135
+#define ZEND_ASSIGN_OBJ                      136
+#define ZEND_INSTANCEOF                      138
+#define ZEND_DECLARE_CLASS                   139
+#define ZEND_DECLARE_INHERITED_CLASS         140
+#define ZEND_DECLARE_FUNCTION                141
+#define ZEND_RAISE_ABSTRACT_ERROR            142
+#define ZEND_DECLARE_CONST                   143
+#define ZEND_ADD_INTERFACE                   144
+#define ZEND_DECLARE_INHERITED_CLASS_DELAYED 145
+#define ZEND_VERIFY_ABSTRACT_CLASS           146
+#define ZEND_ASSIGN_DIM                      147
+#define ZEND_ISSET_ISEMPTY_PROP_OBJ          148
+#define ZEND_HANDLE_EXCEPTION                149
+#define ZEND_USER_OPCODE                     150
+#define ZEND_JMP_SET                         152
+#define ZEND_DECLARE_LAMBDA_FUNCTION         153
+#define ZEND_ADD_TRAIT                       154
+#define ZEND_BIND_TRAITS                     155
+#define ZEND_SEPARATE                        156
+#define ZEND_QM_ASSIGN_VAR                   157
+#define ZEND_JMP_SET_VAR                     158
+#define ZEND_DISCARD_EXCEPTION               159
+#define ZEND_YIELD                           160
+#define ZEND_GENERATOR_RETURN                161
+#define ZEND_FAST_CALL                       162
+#define ZEND_FAST_RET                        163
+#define ZEND_RECV_VARIADIC                   164
+
+#endif
\ No newline at end of file