diff --git a/Zend/tests/pattern_matching/is/and.phpt b/Zend/tests/pattern_matching/is/and.phpt
new file mode 100644
index 0000000000000..9cb597f2b27e6
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/and.phpt
@@ -0,0 +1,29 @@
+--TEST--
+And pattern
+--FILE--
+<?php
+
+interface A {}
+interface B {}
+interface C {}
+class Foo implements A, B {}
+
+var_dump(1 is int & 1);
+var_dump(2 is int & (1|2));
+var_dump(3 is float & 1);
+var_dump(4 is int & float);
+var_dump([] is [] & [...]);
+var_dump('foo' is string & 'bar');
+var_dump(new Foo() is A&B);
+var_dump(new Foo() is (A&C));
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(false)
diff --git a/Zend/tests/pattern_matching/is/array.phpt b/Zend/tests/pattern_matching/is/array.phpt
new file mode 100644
index 0000000000000..43f452e62ddf3
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/array.phpt
@@ -0,0 +1,30 @@
+--TEST--
+Array pattern
+--FILE--
+<?php
+
+var_dump([] is []);
+var_dump(42 is []);
+var_dump('foo' is []);
+var_dump([42] is [42]);
+var_dump([42] is []);
+var_dump([42] is [43]);
+var_dump([42] is ['0' => 42]);
+var_dump([42, 43] is [42]);
+var_dump([42, 43] is [42, ...]);
+var_dump([42] is [$a]);
+var_dump($a);
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+int(42)
diff --git a/Zend/tests/pattern_matching/is/array_mixed_keys.phpt b/Zend/tests/pattern_matching/is/array_mixed_keys.phpt
new file mode 100644
index 0000000000000..339efe571ca26
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/array_mixed_keys.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Array pattern with mixed implicit and explicit keys
+--FILE--
+<?php
+
+var_dump([] is ['foo', 1 => 'bar']);
+
+?>
+--EXPECTF--
+Fatal error: Must not mix implicit and explicit array keys in array pattern in %s on line %d
diff --git a/Zend/tests/pattern_matching/is/bail.phpt b/Zend/tests/pattern_matching/is/bail.phpt
new file mode 100644
index 0000000000000..033dca5218545
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/bail.phpt
@@ -0,0 +1,32 @@
+--TEST--
+Object pattern matching
+--FILE--
+<?php
+
+(function () {
+    $o = new stdClass();
+
+    try {
+        var_dump($o is self);
+    } catch (Throwable $e) {
+        echo $e->getMessage(), "\n";
+    }
+
+    try {
+        var_dump($o is parent);
+    } catch (Throwable $e) {
+        echo $e->getMessage(), "\n";
+    }
+
+    try {
+        var_dump($o is static);
+    } catch (Throwable $e) {
+        echo $e->getMessage(), "\n";
+    }
+})();
+
+?>
+--EXPECT--
+Cannot access "self" when no class scope is active
+Cannot access "parent" when no class scope is active
+Cannot access "static" when no class scope is active
diff --git a/Zend/tests/pattern_matching/is/binding.phpt b/Zend/tests/pattern_matching/is/binding.phpt
new file mode 100644
index 0000000000000..8dfbfb807b9ea
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/binding.phpt
@@ -0,0 +1,87 @@
+--TEST--
+Binding pattern
+--FILE--
+<?php
+
+class Box {
+    public function __construct(
+        public $value,
+    ) {}
+}
+
+class NotBox {
+    public function __construct(
+        public $value,
+    ) {}
+}
+
+class Many {
+    public function __construct(
+        public $a = 1,
+        public $b = 2,
+        public $c = 3,
+        public $d = 4,
+        public $e = 5,
+        public $f = 6,
+        public $g = 7,
+        public $h = 8,
+        public $i = 9,
+        public $j = 10,
+    ) {}
+}
+
+var_dump(10 is $a);
+var_dump($a);
+
+var_dump('Hello world' is $a);
+var_dump($a);
+
+var_dump(new Box(42) is Box & { value: $a });
+var_dump($a);
+
+var_dump(new NotBox(43) is Box & { value: $a });
+var_dump($a);
+
+var_dump(43 is $a & int);
+var_dump($a);
+
+var_dump([] is $a & string);
+var_dump($a);
+
+var_dump(new Many() is { $a, $b, $c, $d });
+var_dump($a, $b, $c, $d, isset($e));
+
+var_dump(new Many() is { $a, $b, $c, $d, $e, $f, $g, $h, $i, $j });
+var_dump($a, $b, $c, $d, $e, $f, $g, $h, $i, $j);
+
+?>
+--EXPECT--
+bool(true)
+int(10)
+bool(true)
+string(11) "Hello world"
+bool(true)
+int(42)
+bool(false)
+int(42)
+bool(true)
+int(43)
+bool(false)
+int(43)
+bool(true)
+int(1)
+int(2)
+int(3)
+int(4)
+bool(false)
+bool(true)
+int(1)
+int(2)
+int(3)
+int(4)
+int(5)
+int(6)
+int(7)
+int(8)
+int(9)
+int(10)
diff --git a/Zend/tests/pattern_matching/is/binding_destruct.phpt b/Zend/tests/pattern_matching/is/binding_destruct.phpt
new file mode 100644
index 0000000000000..d99c8d73549b5
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/binding_destruct.phpt
@@ -0,0 +1,28 @@
+--TEST--
+Object pattern matching destructor
+--FILE--
+<?php
+
+class Foo {
+    public function __destruct() {
+        throw new Exception('Here');
+    }
+}
+
+$foo = new Foo();
+$bar = 'bar';
+
+try {
+    42 is $foo & $bar;
+} catch (Exception $e) {
+    echo $e->getMessage(), "\n";
+}
+
+var_dump($foo);
+var_dump($bar);
+
+?>
+--EXPECT--
+Here
+int(42)
+string(3) "bar"
diff --git a/Zend/tests/pattern_matching/is/binding_in_or_001.phpt b/Zend/tests/pattern_matching/is/binding_in_or_001.phpt
new file mode 100644
index 0000000000000..cc4a7e67c81e7
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/binding_in_or_001.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Must not bind to variables in | pattern
+--FILE--
+<?php
+var_dump(42 is $foo|$bar);
+?>
+--EXPECTF--
+Fatal error: Must not bind to variables inside | pattern in %s on line %d
diff --git a/Zend/tests/pattern_matching/is/binding_in_or_002.phpt b/Zend/tests/pattern_matching/is/binding_in_or_002.phpt
new file mode 100644
index 0000000000000..23beb97e6c667
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/binding_in_or_002.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Must not bind to variables in | pattern
+--FILE--
+<?php
+var_dump(42 is 42|(43 & $bar));
+?>
+--EXPECTF--
+Fatal error: Must not bind to variables inside | pattern in %s on line %d
diff --git a/Zend/tests/pattern_matching/is/bug_001.phpt b/Zend/tests/pattern_matching/is/bug_001.phpt
new file mode 100644
index 0000000000000..1a4f2d417d2c5
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/bug_001.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Bug 001
+--FILE--
+<?php
+
+function test() {
+    $x = 42;
+    43 is $x;
+    var_dump($x);
+}
+
+test();
+
+?>
+--EXPECT--
+int(43)
diff --git a/Zend/tests/pattern_matching/is/class_constant.phpt b/Zend/tests/pattern_matching/is/class_constant.phpt
new file mode 100644
index 0000000000000..62573440b2a3d
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/class_constant.phpt
@@ -0,0 +1,44 @@
+--TEST--
+Class constant pattern
+--FILE--
+<?php
+
+class Foo {
+    const A = 'a';
+    private const B = 'b';
+
+    public static function test() {
+        var_dump('b' is self::B);
+        var_dump('c' is self::B);
+    }
+}
+enum Bar {
+    case A;
+}
+
+var_dump('a' is Foo::A);
+var_dump('b' is Foo::A);
+try {
+    var_dump('a' is Foo::B);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+try {
+    var_dump('a' is Foo::C);
+} catch (Error $e) {
+    echo $e->getMessage(), "\n";
+}
+Foo::test();
+var_dump(Bar::A is Bar::A);
+var_dump('foo' is Bar::A);
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
+Cannot access private constant Foo::B
+Undefined constant Foo::C
+bool(true)
+bool(false)
+bool(true)
+bool(false)
diff --git a/Zend/tests/pattern_matching/is/compound_parentheses_1.phpt b/Zend/tests/pattern_matching/is/compound_parentheses_1.phpt
new file mode 100644
index 0000000000000..63f8230d4a1e7
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/compound_parentheses_1.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Nested compound patterns require parentheses
+--FILE--
+<?php
+var_dump(42 is Foo|Bar&Baz);
+?>
+--EXPECTF--
+Fatal error: Nested compound pattern must be parenthesized in %s on line %d
diff --git a/Zend/tests/pattern_matching/is/compound_parentheses_2.phpt b/Zend/tests/pattern_matching/is/compound_parentheses_2.phpt
new file mode 100644
index 0000000000000..8694c7705bd9f
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/compound_parentheses_2.phpt
@@ -0,0 +1,8 @@
+--TEST--
+Nested compound patterns require parentheses
+--FILE--
+<?php
+var_dump(42 is Foo&Bar|Baz);
+?>
+--EXPECTF--
+Fatal error: Nested compound pattern must be parenthesized in %s on line %d
diff --git a/Zend/tests/pattern_matching/is/delayed_binding.phpt b/Zend/tests/pattern_matching/is/delayed_binding.phpt
new file mode 100644
index 0000000000000..e82a9ae096904
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/delayed_binding.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Delayed binding
+--FILE--
+<?php
+
+class Pair {
+    public function __construct(public $a, public $b) {}
+}
+
+var_dump(new Pair(1, 2) is { a: $a, b: $b });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(1, 2) is { a: $a, b: 3 });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(new \stdClass(), 2) is { a: $a, b: 2 });
+var_dump($a, $b);
+unset($a, $b);
+
+var_dump(new Pair(new \stdClass(), 2) is { a: $a, b: 3 });
+var_dump($a, $b);
+unset($a, $b);
+
+?>
+--EXPECTF--
+bool(true)
+int(1)
+int(2)
+bool(false)
+
+Warning: Undefined variable $a in %s on line %d
+
+Warning: Undefined variable $b in %s on line %d
+NULL
+NULL
+bool(true)
+
+Warning: Undefined variable $b in %s on line %d
+object(stdClass)#2 (0) {
+}
+NULL
+bool(false)
+
+Warning: Undefined variable $a in %s on line %d
+
+Warning: Undefined variable $b in %s on line %d
+NULL
+NULL
diff --git a/Zend/tests/pattern_matching/is/object.phpt b/Zend/tests/pattern_matching/is/object.phpt
new file mode 100644
index 0000000000000..a2002ca8f6667
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/object.phpt
@@ -0,0 +1,127 @@
+--TEST--
+Object pattern matching
+--FILE--
+<?php
+
+class Foo {
+    public function __construct(
+        public int $a,
+    ) {}
+
+    public static function isSelfFoo($value) {
+        return $value is self;
+    }
+
+    public static function isStaticFoo($value) {
+        return $value is static;
+    }
+}
+
+class Bar extends Foo implements Baz {
+    public static function isSelfBar($value) {
+        return $value is self;
+    }
+
+    public static function isParentBar($value) {
+        return $value is parent;
+    }
+}
+
+interface Baz {}
+class Qux {}
+
+$foo = new Foo(42);
+$bar = new Bar(43);
+$qux = new Qux();
+
+var_dump($foo is Foo);
+var_dump($foo is Bar);
+var_dump($foo is Baz);
+var_dump($foo is Qux);
+var_dump($foo is Quux);
+var_dump($bar is Foo);
+var_dump($bar is Bar);
+var_dump($bar is Baz);
+var_dump($bar is Qux);
+var_dump($bar is Quux);
+var_dump(null is Foo);
+var_dump(null is Bar);
+var_dump(null is Baz);
+var_dump(null is Qux);
+var_dump(null is Quux);
+
+var_dump($foo is { a: 42 });
+var_dump($foo is { a: 42|43 });
+var_dump($foo is { a: 'hello world' });
+var_dump($foo is { b: 42 });
+var_dump($bar is { a: 42 });
+var_dump($bar is { a: 42|43 });
+var_dump($bar is { a: 'hello world' });
+var_dump($bar is { b: 42 });
+
+var_dump(Foo::isSelfFoo($foo));
+var_dump(Foo::isSelfFoo($bar));
+var_dump(Foo::isSelfFoo($qux));
+var_dump(Foo::isStaticFoo($foo));
+var_dump(Foo::isStaticFoo($bar));
+var_dump(Foo::isStaticFoo($qux));
+var_dump(Bar::isSelfFoo($foo));
+var_dump(Bar::isSelfFoo($bar));
+var_dump(Bar::isSelfFoo($qux));
+var_dump(Bar::isStaticFoo($foo));
+var_dump(Bar::isStaticFoo($bar));
+var_dump(Bar::isStaticFoo($qux));
+var_dump(Bar::isSelfBar($foo));
+var_dump(Bar::isSelfBar($bar));
+var_dump(Bar::isSelfBar($qux));
+var_dump(Bar::isParentBar($foo));
+var_dump(Bar::isParentBar($bar));
+var_dump(Bar::isParentBar($qux));
+
+?>
+--EXPECTF--
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+
+Warning: Undefined property: Foo::$b in %s on line %d
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+
+Warning: Undefined property: Bar::$b in %s on line %d
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
diff --git a/Zend/tests/pattern_matching/is/object_shorthand.phpt b/Zend/tests/pattern_matching/is/object_shorthand.phpt
new file mode 100644
index 0000000000000..61786df10ad4e
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/object_shorthand.phpt
@@ -0,0 +1,22 @@
+--TEST--
+Object pattern matching
+--FILE--
+<?php
+
+class Foo {
+    public function __construct(public $a, public $b) {}
+}
+
+var_dump(new Foo(1, 2) is { $a, b: 2 });
+var_dump($a);
+var_dump(new Foo(1, 2) is { a: 3, $b });
+var_dump($b);
+
+?>
+--EXPECTF--
+bool(true)
+int(1)
+bool(false)
+
+Warning: Undefined variable $b in %s on line %d
+NULL
diff --git a/Zend/tests/pattern_matching/is/or.phpt b/Zend/tests/pattern_matching/is/or.phpt
new file mode 100644
index 0000000000000..4294332d81a1f
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/or.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Or pattern
+--FILE--
+<?php
+
+var_dump(1 is 1|2|3);
+var_dump(2 is 1|2|3);
+var_dump(3 is 1|2|3);
+var_dump(4 is 1|2|3);
+var_dump(null is 1|2|3);
+var_dump([] is 1|2|3);
+var_dump('hello world' is (1|2|3));
+var_dump('hello world' is 1|2|3 === false);
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
diff --git a/Zend/tests/pattern_matching/is/range.phpt b/Zend/tests/pattern_matching/is/range.phpt
new file mode 100644
index 0000000000000..90616c6525de9
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/range.phpt
@@ -0,0 +1,41 @@
+--TEST--
+Or pattern
+--FILE--
+<?php
+
+var_dump(0 is 0 ..< 10);
+var_dump(5 is 0 ..< 10);
+var_dump(10 is 0 ..< 10);
+var_dump(11 is 0 ..< 10);
+var_dump(0 is 0 ..= 10);
+var_dump(5 is 0 ..= 10);
+var_dump(10 is 0 ..= 10);
+var_dump(11 is 0 ..= 10);
+
+var_dump('a' is 'a' ..< 'c');
+var_dump('b' is 'a' ..< 'c');
+var_dump('c' is 'a' ..< 'c');
+var_dump('d' is 'a' ..< 'c');
+var_dump('a' is 'a' ..= 'c');
+var_dump('b' is 'a' ..= 'c');
+var_dump('c' is 'a' ..= 'c');
+var_dump('d' is 'a' ..= 'c');
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(true)
+bool(false)
diff --git a/Zend/tests/pattern_matching/is/rcd_expr.phpt b/Zend/tests/pattern_matching/is/rcd_expr.phpt
new file mode 100644
index 0000000000000..f76c80262f0ab
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/rcd_expr.phpt
@@ -0,0 +1,19 @@
+--TEST--
+Refcoutned expression
+--FILE--
+<?php
+
+class Foo {}
+
+var_dump(new Foo() is Foo);
+var_dump(new Foo() is Bar);
+var_dump(match (new Foo()) {
+    is Bar => throw new Exception('Unreachable'),
+    is Foo => 'foo',
+});
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
+string(3) "foo"
diff --git a/Zend/tests/pattern_matching/is/scalar.phpt b/Zend/tests/pattern_matching/is/scalar.phpt
new file mode 100644
index 0000000000000..fdcd7d8f9c3af
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/scalar.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Scalar pattern matching
+--FILE--
+<?php
+
+var_dump(1 is 1);
+var_dump(1.0 is 1);
+var_dump('1' is 1);
+var_dump(1 is 1.0);
+var_dump(1.0 is 1.0);
+var_dump('1' is 1.0);
+var_dump(1 is '1');
+var_dump(1.0 is '1');
+var_dump('1' is '1');
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
diff --git a/Zend/tests/pattern_matching/is/type.phpt b/Zend/tests/pattern_matching/is/type.phpt
new file mode 100644
index 0000000000000..252e51bcc9469
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/type.phpt
@@ -0,0 +1,25 @@
+--TEST--
+Type pattern matching
+--FILE--
+<?php
+
+class Foo {}
+$foo = new Foo();
+
+var_dump('' is string);
+var_dump('' is int);
+var_dump('' is bool);
+var_dump('' is object);
+var_dump('' is ?string);
+var_dump(null is ?string);
+var_dump('' is ?object);
+
+?>
+--EXPECT--
+bool(true)
+bool(false)
+bool(false)
+bool(false)
+bool(true)
+bool(true)
+bool(false)
diff --git a/Zend/tests/pattern_matching/is/wildcard.phpt b/Zend/tests/pattern_matching/is/wildcard.phpt
new file mode 100644
index 0000000000000..0cb473e725f34
--- /dev/null
+++ b/Zend/tests/pattern_matching/is/wildcard.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Wildcard pattern matching
+--FILE--
+<?php
+
+class Foo {}
+
+var_dump('' is *);
+var_dump(42 is *);
+var_dump(3.141 is *);
+var_dump(null is *);
+var_dump(true is *);
+var_dump(new Foo() is *);
+var_dump([1, 2, 3] is *);
+
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
diff --git a/Zend/tests/pattern_matching/match/basic.phpt b/Zend/tests/pattern_matching/match/basic.phpt
new file mode 100644
index 0000000000000..0d264abf59937
--- /dev/null
+++ b/Zend/tests/pattern_matching/match/basic.phpt
@@ -0,0 +1,80 @@
+--TEST--
+Test basic pattern matching
+--FILE--
+<?php
+
+function wrong() {
+    throw new Exception();
+}
+
+class Foo {
+    const FOO = 'foo';
+}
+
+var_dump(match (null) {
+    is false => wrong(),
+    is 0 => wrong(),
+    is [] => wrong(),
+    is null =>  'Literal pattern with null',
+});
+
+var_dump(match (true) {
+    is false => wrong(),
+    is true => 'Literal pattern with bool',
+});
+
+var_dump(match (4) {
+    is 1 => wrong(),
+    is 2 => wrong(),
+    is 3 => wrong(),
+    is 4 => 'Literal pattern with int',
+    is 5 => wrong(),
+    is 6 => wrong(),
+});
+
+var_dump(match ('e') {
+    is 'a' => wrong(),
+    is 'b' => wrong(),
+    is 'c' => wrong(),
+    is 'd' => wrong(),
+    is 'e' => 'Literal pattern with string',
+    is 'f' => wrong(),
+    is 'g' => wrong(),
+});
+
+var_dump(match ('Foo') {
+    is 1 => wrong(),
+    is 2 => wrong(),
+    is 3 => wrong(),
+    is $a => 'Identifier pattern: ' . $a,
+    is 5 => wrong(),
+    is 6 => wrong(),
+});
+
+var_dump(match ('Foo') {
+    is 1 => wrong(),
+    is 2 => wrong(),
+    is 3 => wrong(),
+    is * => 'Wildcard pattern',
+});
+
+var_dump(match (15) {
+    is 0 ..< 10 => wrong(),
+    is 10 ..< 20 => 'Range pattern',
+    is 20 ..< 30 => wrong(),
+});
+
+// var_dump(match ('foo') {
+//     is 'bar' => wrong(),
+//     is Foo::FOO => 'Class constant literal',
+// });
+
+?>
+--EXPECT--
+string(25) "Literal pattern with null"
+string(25) "Literal pattern with bool"
+string(24) "Literal pattern with int"
+string(27) "Literal pattern with string"
+string(23) "Identifier pattern: Foo"
+string(16) "Wildcard pattern"
+string(13) "Range pattern"
diff --git a/Zend/tests/pattern_matching/match/scalar.phpt b/Zend/tests/pattern_matching/match/scalar.phpt
new file mode 100644
index 0000000000000..73035674eeca8
--- /dev/null
+++ b/Zend/tests/pattern_matching/match/scalar.phpt
@@ -0,0 +1,14 @@
+--TEST--
+Scalar pattern matching
+--FILE--
+<?php
+
+var_dump(match (2) {
+    is 1 => 1,
+    is 2 => 2,
+    is 3 => 3,
+});
+
+?>
+--EXPECT--
+int(2)
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index fb48b187252b3..ca8e54839ac01 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -70,12 +70,15 @@ enum _zend_ast_kind {
 	ZEND_AST_ATTRIBUTE_GROUP,
 	ZEND_AST_MATCH_ARM_LIST,
 	ZEND_AST_MODIFIER_LIST,
+	ZEND_AST_OBJECT_PATTERN_ELEMENT_LIST,
+	ZEND_AST_ARRAY_PATTERN_ELEMENT_LIST,
 
 	/* 0 child nodes */
 	ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT,
 	ZEND_AST_TYPE,
 	ZEND_AST_CONSTANT_CLASS,
 	ZEND_AST_CALLABLE_CONVERT,
+	ZEND_AST_WILDCARD_PATTERN,
 
 	/* 1 child node */
 	ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT,
@@ -111,6 +114,10 @@ enum _zend_ast_kind {
 	ZEND_AST_BREAK,
 	ZEND_AST_CONTINUE,
 	ZEND_AST_PROPERTY_HOOK_SHORT_BODY,
+	ZEND_AST_TYPE_PATTERN,
+	ZEND_AST_ARRAY_PATTERN,
+	ZEND_AST_BINDING_PATTERN,
+	ZEND_AST_OBJECT_PATTERN,
 
 	/* 2 child nodes */
 	ZEND_AST_DIM = 2 << ZEND_AST_NUM_CHILDREN_SHIFT,
@@ -154,6 +161,13 @@ enum _zend_ast_kind {
 	ZEND_AST_NAMED_ARG,
 	ZEND_AST_PARENT_PROPERTY_HOOK_CALL,
 	ZEND_AST_PIPE,
+	ZEND_AST_IS,
+	ZEND_AST_OR_PATTERN,
+	ZEND_AST_AND_PATTERN,
+	ZEND_AST_OBJECT_PATTERN_ELEMENT,
+	ZEND_AST_RANGE_PATTERN,
+	ZEND_AST_ARRAY_PATTERN_ELEMENT,
+	ZEND_AST_CLASS_CONST_PATTERN,
 
 	/* 3 child nodes */
 	ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT,
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 4632a3fca189f..db7f5c2858a66 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -6551,6 +6551,10 @@ static bool can_match_use_jumptable(const zend_ast_list *arms) {
 		for (uint32_t j = 0; j < conds->children; j++) {
 			zend_ast **cond_ast = &conds->child[j];
 
+			if ((*cond_ast)->kind == ZEND_AST_IS) {
+				return 0;
+			}
+
 			zend_eval_const_expr(cond_ast);
 			if ((*cond_ast)->kind != ZEND_AST_ZVAL) {
 				return 0;
@@ -6637,6 +6641,15 @@ static void zend_compile_pipe(znode *result, zend_ast *ast)
 	zend_compile_expr(result, fcall_ast);
 }
 
+static void zend_compile_pattern(zend_ast **ast_ptr, void *context);
+static uint32_t zend_emit_is(znode *result, znode *expr_node, zend_ast **pattern_ast_ptr);
+
+typedef struct {
+	bool inside_or_pattern;
+	uint32_t bindings_var;
+	uint32_t binding_offset;
+} zend_compile_pattern_context;
+
 static void zend_compile_match(znode *result, zend_ast *ast)
 {
 	zend_ast *expr_ast = ast->child[0];
@@ -6697,14 +6710,21 @@ static void zend_compile_match(znode *result, zend_ast *ast)
 			for (uint32_t j = 0; j < conds->children; j++) {
 				zend_ast *cond_ast = conds->child[j];
 
-				znode cond_node;
-				zend_compile_expr(&cond_node, cond_ast);
+				if (cond_ast->kind != ZEND_AST_IS) {
+					znode cond_node;
+					zend_compile_expr(&cond_node, cond_ast);
 
-				uint32_t opcode = (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) ? ZEND_CASE_STRICT : ZEND_IS_IDENTICAL;
-				zend_op *opline = zend_emit_op(NULL, opcode, &expr_node, &cond_node);
-				SET_NODE(opline->result, &case_node);
-				if (opline->op1_type == IS_CONST) {
-					Z_TRY_ADDREF_P(CT_CONSTANT(opline->op1));
+					uint32_t opcode = (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) ? ZEND_CASE_STRICT : ZEND_IS_IDENTICAL;
+					zend_op *opline = zend_emit_op(NULL, opcode, &expr_node, &cond_node);
+					SET_NODE(opline->result, &case_node);
+					if (opline->op1_type == IS_CONST) {
+						Z_TRY_ADDREF_P(CT_CONSTANT(opline->op1));
+					}
+				} else {
+					zend_ast **pattern_ast_ptr = &cond_ast->child[1];
+					uint32_t is_opnum = zend_emit_is(NULL, &expr_node, pattern_ast_ptr);
+					zend_op *is_opline = &CG(active_op_array)->opcodes[is_opnum];
+					SET_NODE(is_opline->result, &case_node);
 				}
 
 				jmpnz_opnums[cond_count] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0);
@@ -6823,6 +6843,218 @@ static void zend_compile_match(znode *result, zend_ast *ast)
 	efree(jmp_end_opnums);
 }
 
+static zend_type zend_compile_single_typename(zend_ast *ast);
+
+static void zend_compile_type_pattern(zend_ast **ast_ptr)
+{
+	zend_ast *type_pattern_ast = *ast_ptr;
+	zend_ast *type_ast = type_pattern_ast->child[0];
+	bool nullable = type_ast->attr & ZEND_TYPE_NULLABLE;
+	type_ast->attr &= ~ZEND_TYPE_NULLABLE;
+	zend_type type = zend_compile_single_typename(type_ast);
+	if (nullable) {
+		ZEND_TYPE_FULL_MASK(type) |= MAY_BE_NULL;
+	}
+	uint32_t type_mask = ZEND_TYPE_PURE_MASK(type);
+
+	// FIXME: Make sure the type mask actually fits
+	type_pattern_ast->attr = (uint16_t) type_mask;
+
+	zend_ast_destroy(type_ast);
+	type_pattern_ast->child[0] = NULL;
+
+	if (ZEND_TYPE_IS_COMPLEX(type))  {
+		ZEND_ASSERT(ZEND_TYPE_HAS_NAME(type));
+		zend_string *class_name = ZEND_TYPE_NAME(type);
+		type_pattern_ast->child[0] = zend_ast_create_zval_from_str(class_name);
+	}
+}
+
+static void zend_compile_class_const_pattern(zend_ast **ast_ptr)
+{
+	// zend_ast *ast = *ast_ptr;
+	// FIXME: Compiling the class name breaks zend_get_class_constant_ex.
+	// zend_compile_pattern_class_name(ast);
+}
+
+static void zend_compile_binding_pattern(zend_ast **ast_ptr, zend_compile_pattern_context *context)
+{
+	zend_ast *binding_pattern_ast = *ast_ptr;
+	zend_ast *var_name_ast = binding_pattern_ast->child[0];
+	zend_string *var_name = zend_ast_get_str(var_name_ast);
+	uint32_t var = lookup_cv(var_name);
+
+	uint32_t binding_offset = context->binding_offset++;
+
+	zend_ast_destroy(var_name_ast);
+	binding_pattern_ast->child[0] = NULL;
+	binding_pattern_ast->attr = binding_offset;
+
+	znode bindings_node;
+	bindings_node.op_type = IS_TMP_VAR;
+	bindings_node.u.op.var = context->bindings_var;
+
+	znode offset_node;
+	offset_node.op_type = IS_CONST;
+	ZVAL_LONG(&offset_node.u.constant, binding_offset);
+
+	znode copy_tmp_node;
+	zend_emit_op_tmp(&copy_tmp_node, ZEND_COPY_TMP, &bindings_node, NULL);
+
+	znode dim_result;
+	zend_emit_op_tmp(&dim_result, ZEND_FETCH_DIM_R, &copy_tmp_node, &offset_node);
+
+	znode var_node;
+	var_node.op_type = IS_CV;
+	var_node.u.op.var = var;
+	zend_emit_op_tmp(NULL, ZEND_ASSIGN, &var_node, &dim_result);
+}
+
+static void zend_compile_array_pattern(zend_ast **ast_ptr)
+{
+	zend_ast *array_pattern = *ast_ptr;
+	zend_ast_list *element_list = zend_ast_get_list(array_pattern->child[0]);
+	bool has_implicit = false, has_explicit = false;
+
+	for (uint32_t i = 0; i < element_list->children; i++) {
+		zend_ast *element = element_list->child[i];
+		zend_ast *key_ast = element->child[0];
+		if (key_ast) {
+			has_explicit = true;
+			zval *key = zend_ast_get_zval(key_ast);
+			if (Z_TYPE_P(key) == IS_STRING) {
+				zend_ulong index;
+				if (ZEND_HANDLE_NUMERIC(Z_STR_P(key), index)) {
+					zval_ptr_dtor(key);
+					ZVAL_LONG(key, index);
+				}
+			}
+		} else {
+			has_implicit = true;
+		}
+	}
+	if (has_implicit && has_explicit) {
+		zend_throw_exception(zend_ce_compile_error, "Must not mix implicit and explicit array keys in array pattern", 0);
+	}
+}
+
+static void verify_parenthesized_compound_pattern(zend_ast **ast_ptr, zend_ast_kind kind)
+{
+	zend_ast *ast = *ast_ptr;
+	zend_ast *lhs = ast->child[0];
+	zend_ast *rhs = ast->child[1];
+	if ((lhs->kind == kind && !(lhs->attr & ZEND_PARENTHESIZED_PATTERN))
+	 || (rhs->kind == kind && !(rhs->attr & ZEND_PARENTHESIZED_PATTERN))) {
+		zend_throw_exception(zend_ce_compile_error, "Nested compound pattern must be parenthesized", 0);
+	}
+}
+
+static void zend_compile_or_pattern(zend_ast **ast_ptr)
+{
+	verify_parenthesized_compound_pattern(ast_ptr, ZEND_AST_AND_PATTERN);
+}
+
+static void zend_compile_and_pattern(zend_ast **ast_ptr)
+{
+	verify_parenthesized_compound_pattern(ast_ptr, ZEND_AST_OR_PATTERN);
+}
+
+static void zend_compile_pattern(zend_ast **ast_ptr, void *context)
+{
+	zend_ast *ast = *ast_ptr;
+	if (ast == NULL || ast->kind == ZEND_AST_ZVAL) {
+		return;
+	}
+
+	zend_compile_pattern_context *pattern_context = context;
+	zend_compile_pattern_context tmp_context = {0};
+	if (!pattern_context) {
+		pattern_context = &tmp_context;
+	}
+	bool prev_inside_or_pattern = pattern_context->inside_or_pattern;
+
+	switch (ast->kind) {
+		case ZEND_AST_TYPE_PATTERN:
+			zend_compile_type_pattern(ast_ptr);
+			break;
+		case ZEND_AST_BINDING_PATTERN:
+			if (pattern_context->inside_or_pattern) {
+				zend_throw_exception(zend_ce_compile_error, "Must not bind to variables inside | pattern", 0);
+			}
+			zend_compile_binding_pattern(ast_ptr, context);
+			break;
+		case ZEND_AST_ARRAY_PATTERN:
+			zend_compile_array_pattern(ast_ptr);
+			break;
+		case ZEND_AST_CLASS_CONST_PATTERN:
+			zend_compile_class_const_pattern(ast_ptr);
+			break;
+		case ZEND_AST_OR_PATTERN:
+			pattern_context->inside_or_pattern = true;
+			zend_compile_or_pattern(ast_ptr);
+			break;
+		case ZEND_AST_AND_PATTERN:
+			zend_compile_and_pattern(ast_ptr);
+			break;
+	}
+
+	zend_ast_apply(ast, zend_compile_pattern, pattern_context);
+	pattern_context->inside_or_pattern = prev_inside_or_pattern;
+}
+
+static uint32_t zend_emit_is(znode *result, znode *expr_node, zend_ast **pattern_ast_ptr)
+{
+	znode bindings_node;
+	bindings_node.op_type = IS_TMP_VAR;
+	bindings_node.u.op.var = get_temporary_variable();
+
+	uint32_t is_opnum = get_next_op_number();
+	zend_emit_op_tmp(result, ZEND_IS, expr_node, &bindings_node);
+
+	uint32_t op_data_opnum = get_next_op_number();
+	zend_emit_op_data(NULL);
+
+	zend_compile_pattern_context pattern_context = { .bindings_var = bindings_node.u.op.var };
+	zend_compile_pattern(pattern_ast_ptr, &pattern_context);
+
+	zval pattern_zv;
+	ZVAL_AST(&pattern_zv, zend_ast_copy(*pattern_ast_ptr));
+	zend_ast_destroy(*pattern_ast_ptr);
+	*pattern_ast_ptr = zend_ast_create_zval(&pattern_zv);
+
+	znode pattern_node;
+	pattern_node.op_type = IS_CONST;
+	ZVAL_COPY(&pattern_node.u.constant, &pattern_zv);
+	zend_op *op_data_op = &CG(active_op_array)->opcodes[op_data_opnum];
+	SET_NODE(op_data_op->op1, &pattern_node);
+	op_data_op->extended_value = pattern_context.binding_offset;
+
+	zend_op *is_opline = &CG(active_op_array)->opcodes[is_opnum];
+	is_opline->extended_value = get_next_op_number();
+
+	if (pattern_context.binding_offset) {
+		zend_emit_op(NULL, ZEND_FREE, &bindings_node, NULL);
+	}
+
+	return is_opnum;
+}
+
+static void zend_compile_is(znode *result, zend_ast *ast)
+{
+	zend_ast *expr_ast = ast->child[0];
+	zend_ast **pattern_ast_ptr = &ast->child[1];
+
+	znode expr_node;
+	zend_compile_expr(&expr_node, expr_ast);
+
+	zend_emit_is(result, &expr_node, pattern_ast_ptr);
+
+	if (expr_node.op_type & (IS_VAR|IS_TMP_VAR)) {
+		// FIXME: Verify live ranges recognizes that OP1 needs to be freed if an exception occurs
+		zend_emit_op(NULL, ZEND_FREE, &expr_node, NULL);
+	}
+}
+
 static void zend_compile_try(const zend_ast *ast) /* {{{ */
 {
 	zend_ast *try_ast = ast->child[0];
@@ -12037,6 +12269,9 @@ static void zend_compile_expr_inner(znode *result, zend_ast *ast) /* {{{ */
 		case ZEND_AST_PIPE:
 			zend_compile_pipe(result, ast);
 			return;
+		case ZEND_AST_IS:
+			zend_compile_is(result, ast);
+			return;
 		default:
 			ZEND_ASSERT(0 /* not supported */);
 	}
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 86fab4b57ded6..646aaece75c04 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -1126,6 +1126,8 @@ ZEND_API zend_string *zend_type_to_string(zend_type type);
 
 #define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS 1
 
+#define ZEND_AST_RANGE_INCLUSIVE_END 1
+
 /* The send mode, the is_variadic, the is_promoted, and the is_tentative flags are stored as part of zend_type */
 #define _ZEND_SEND_MODE_SHIFT _ZEND_TYPE_EXTRA_FLAGS_SHIFT
 #define _ZEND_IS_VARIADIC_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 2))
@@ -1153,6 +1155,9 @@ ZEND_API zend_string *zend_type_to_string(zend_type type);
 #define IS_CONSTANT_CLASS                    0x400 /* __CLASS__ in trait */
 #define IS_CONSTANT_UNQUALIFIED_IN_NAMESPACE 0x800
 
+/* Array pattern contains ... */
+#define ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE 1
+
 static zend_always_inline bool zend_check_arg_send_type(const zend_function *zf, uint32_t arg_num, uint32_t mask)
 {
 	arg_num--;
@@ -1224,6 +1229,8 @@ static zend_always_inline bool zend_check_arg_send_type(const zend_function *zf,
 /* Used to disallow pipes with arrow functions that lead to confusing parse trees. */
 #define ZEND_PARENTHESIZED_ARROW_FUNC 1
 
+#define ZEND_PARENTHESIZED_PATTERN 1
+
 /* For "use" AST nodes and the seen symbol table */
 #define ZEND_SYMBOL_CLASS    (1<<0)
 #define ZEND_SYMBOL_FUNCTION (1<<1)
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index d411dcbc3b953..20ffa4fab3b79 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -44,6 +44,7 @@
 #include "zend_system_id.h"
 #include "zend_call_stack.h"
 #include "zend_attributes.h"
+#include "zend_pattern_matching.h"
 #include "Optimizer/zend_func_info.h"
 
 /* Virtual current working directory support */
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 660975f9bc1b5..59ad5f370d500 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -39,6 +39,7 @@
 #include "zend_observer.h"
 #include "zend_call_stack.h"
 #include "zend_frameless_function.h"
+#include "zend_pattern_matching.h"
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index ef81ae5faaf25..82621ad2e9e3c 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -43,6 +43,7 @@
 #include "zend_max_execution_timer.h"
 #include "zend_strtod.h"
 #include "zend_lazy_objects.h"
+#include "zend_pattern_matching.h"
 
 /* Define ZTS if you want a thread-safe Zend */
 /*#undef ZTS*/
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index e4d61006fe12f..c2bcb86b33c71 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -52,6 +52,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %destructor { if ($$) zend_string_release_ex($$, 0); } <str>
 
 %precedence T_THROW
+%precedence T_IS
 %precedence PREC_ARROW_FUNCTION
 %precedence T_INCLUDE T_INCLUDE_ONCE T_REQUIRE T_REQUIRE_ONCE
 %left T_LOGICAL_OR
@@ -135,6 +136,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token <ident> T_CASE          "'case'"
 %token <ident> T_DEFAULT       "'default'"
 %token <ident> T_MATCH         "'match'"
+%token <ident> T_IS            "'is'"
 %token <ident> T_BREAK         "'break'"
 %token <ident> T_CONTINUE      "'continue'"
 %token <ident> T_GOTO          "'goto'"
@@ -239,6 +241,8 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %token T_POW             "'**'"
 %token T_POW_EQUAL       "'**='"
 %token T_PIPE         "'|>'"
+%token T_RANGE_EXCLUSIVE_END "'..<'"
+%token T_RANGE_INCLUSIVE_END "'..='"
 /* We need to split the & token in two to avoid a shift/reduce conflict. For T1&$v and T1&T2,
  * with only one token lookahead, bison does not know whether to reduce T1 as a complete type,
  * or shift to continue parsing an intersection type. */
@@ -283,11 +287,15 @@ static YYSIZE_T zend_yytnamerr(char*, const char*);
 %type <ast> inline_function union_type_element union_type intersection_type
 %type <ast> attributed_statement attributed_top_statement attributed_class_statement attributed_parameter
 %type <ast> attribute_decl attribute attributes attribute_group namespace_declaration_name
-%type <ast> match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list
+%type <ast> match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list match_arm_cond
 %type <ast> enum_declaration_statement enum_backing_type enum_case enum_case_expr
 %type <ast> function_name non_empty_member_modifiers
 %type <ast> property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body
 %type <ast> optional_parameter_list clone_argument_list non_empty_clone_argument_list
+%type <ast> pattern atomic_pattern compound_pattern type_pattern scalar_pattern or_pattern and_pattern class_const_pattern
+%type <ast> object_pattern object_pattern_element_list non_empty_object_pattern_element_list
+%type <ast> object_pattern_element range_pattern binding_pattern
+%type <ast> array_pattern array_pattern_element_list array_pattern_element
 
 %type <num> returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers
 %type <num> method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers
@@ -312,7 +320,7 @@ reserved_non_modifiers:
 	| T_FUNCTION | T_CONST | T_RETURN | T_PRINT | T_YIELD | T_LIST | T_SWITCH | T_ENDSWITCH | T_CASE | T_DEFAULT | T_BREAK
 	| T_ARRAY | T_CALLABLE | T_EXTENDS | T_IMPLEMENTS | T_NAMESPACE | T_TRAIT | T_INTERFACE | T_CLASS
 	| T_CLASS_C | T_TRAIT_C | T_FUNC_C | T_METHOD_C | T_LINE | T_FILE | T_DIR | T_NS_C | T_FN | T_MATCH | T_ENUM
-	| T_PROPERTY_C
+	| T_PROPERTY_C | T_IS
 ;
 
 semi_reserved:
@@ -582,6 +590,11 @@ function_name:
 			if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; }
 			$$ = zend_ast_create_zval(&zv);
 		}
+	|	T_IS {
+			zval zv;
+			if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; }
+			$$ = zend_ast_create_zval(&zv);
+		}
 ;
 
 function_declaration_statement:
@@ -747,8 +760,13 @@ match_arm:
 ;
 
 match_arm_cond_list:
-		expr { $$ = zend_ast_create_list(1, ZEND_AST_EXPR_LIST, $1); }
-	|	match_arm_cond_list ',' expr { $$ = zend_ast_list_add($1, $3); }
+		match_arm_cond { $$ = zend_ast_create_list(1, ZEND_AST_EXPR_LIST, $1); }
+	|	match_arm_cond_list ',' match_arm_cond { $$ = zend_ast_list_add($1, $3); }
+;
+
+match_arm_cond:
+		expr { $$ = $1; }
+	|	T_IS pattern { $$ = zend_ast_create(ZEND_AST_IS, NULL, $2); }
 ;
 
 
@@ -1386,8 +1404,122 @@ expr:
 	|	attributes T_STATIC inline_function
 			{ $$ = zend_ast_with_attributes($3, $1); ((zend_ast_decl *) $$)->flags |= ZEND_ACC_STATIC; }
 	|	match { $$ = $1; }
+	|	expr T_IS pattern { $$ = zend_ast_create(ZEND_AST_IS, $1, $3); }
+;
+
+pattern:
+		atomic_pattern { $$ = $1; }
+	|	compound_pattern { $$ = $1; }
+;
+
+atomic_pattern:
+		scalar_pattern { $$ = $1; }
+	|	type_pattern { $$ = $1; }
+	|	object_pattern { $$ = $1; }
+	|	range_pattern { $$ = $1; }
+	|	array_pattern { $$ = $1; }
+	|	binding_pattern { $$ = $1; }
+	|	class_const_pattern { $$ = $1; }
+	|	'*' { $$ = zend_ast_create(ZEND_AST_WILDCARD_PATTERN); }
+	|	'(' pattern ')' {
+			$$ = $2;
+			if ($$->kind == ZEND_AST_OR_PATTERN || $$->kind == ZEND_AST_AND_PATTERN) {
+				$$->attr = ZEND_PARENTHESIZED_CONDITIONAL;
+			}
+		}
+;
+
+compound_pattern:
+		or_pattern { $$ = $1; }
+	|	and_pattern { $$ = $1; }
+;
+
+type_pattern:
+		type		{ $$ = zend_ast_create(ZEND_AST_TYPE_PATTERN, $1); }
+	|	'?' type	{ $$ = zend_ast_create(ZEND_AST_TYPE_PATTERN, $2); $2->attr |= ZEND_TYPE_NULLABLE; }
+;
+
+scalar_pattern:
+		T_LNUMBER { $$ = $1; }
+	|	T_DNUMBER { $$ = $1; }
+	|	T_CONSTANT_ENCAPSED_STRING { $$ = $1; }
+	|	'"' '"' { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
+	|	'"' T_ENCAPSED_AND_WHITESPACE '"' { $$ = $2; }
+	|	T_START_HEREDOC T_END_HEREDOC { $$ = zend_ast_create_zval_from_str(ZSTR_EMPTY_ALLOC()); }
+	|	T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; }
+;
+
+object_pattern:
+		'{' object_pattern_element_list '}' { $$ = zend_ast_create(ZEND_AST_OBJECT_PATTERN, $2); }
+;
+
+object_pattern_element_list:
+		%empty { $$ = zend_ast_create_list(0, ZEND_AST_OBJECT_PATTERN_ELEMENT_LIST); }
+	|	non_empty_object_pattern_element_list { $$ = $1; }
+	|	non_empty_object_pattern_element_list ',' { $$ = $1; }
+;
+
+non_empty_object_pattern_element_list:
+		object_pattern_element { $$ = zend_ast_create_list(1, ZEND_AST_OBJECT_PATTERN_ELEMENT_LIST, $1); }
+	|	non_empty_object_pattern_element_list ',' object_pattern_element { $$ = zend_ast_list_add($1, $3); }
+;
+
+object_pattern_element:
+		T_STRING ':' pattern { $$ = zend_ast_create(ZEND_AST_OBJECT_PATTERN_ELEMENT, $1, $3); }
+	|	binding_pattern {
+			zend_string *name = zend_string_copy(zend_ast_get_str($1->child[0]));
+			$$ = zend_ast_create(ZEND_AST_OBJECT_PATTERN_ELEMENT, zend_ast_create_zval_from_str(name), $1);
+		}
+;
+
+or_pattern:
+		pattern '|' pattern { $$ = zend_ast_create(ZEND_AST_OR_PATTERN, $1, $3); }
+;
+
+and_pattern:
+		pattern T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG pattern { $$ = zend_ast_create(ZEND_AST_AND_PATTERN, $1, $3); }
+	|	pattern T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG pattern { $$ = zend_ast_create(ZEND_AST_AND_PATTERN, $1, $3); }
+;
+
+range_pattern:
+		scalar_pattern T_RANGE_EXCLUSIVE_END scalar_pattern { $$ = zend_ast_create(ZEND_AST_RANGE_PATTERN, $1, $3); }
+	|	scalar_pattern T_RANGE_INCLUSIVE_END scalar_pattern
+			{ $$ = zend_ast_create(ZEND_AST_RANGE_PATTERN, $1, $3); $$->attr = ZEND_AST_RANGE_INCLUSIVE_END; }
 ;
 
+binding_pattern:
+		T_VARIABLE { $$ = zend_ast_create(ZEND_AST_BINDING_PATTERN, $1); }
+;
+
+array_pattern:
+		'[' ']' { $$ = zend_ast_create(ZEND_AST_ARRAY_PATTERN, zend_ast_create_list(0, ZEND_AST_ARRAY_PATTERN_ELEMENT_LIST)); }
+	|	'[' T_ELLIPSIS ']' {
+			$$ = zend_ast_create_ex(
+				ZEND_AST_ARRAY_PATTERN,
+				ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE,
+				zend_ast_create_list(0, ZEND_AST_ARRAY_PATTERN_ELEMENT_LIST));
+		}
+	|	'[' array_pattern_element_list possible_comma ']' { $$ = zend_ast_create(ZEND_AST_ARRAY_PATTERN, $2); }
+	|	'[' array_pattern_element_list ',' T_ELLIPSIS ']' {
+			$$ = zend_ast_create_ex(ZEND_AST_ARRAY_PATTERN, ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE, $2);
+		}
+;
+
+array_pattern_element_list:
+		array_pattern_element { $$ = zend_ast_create_list(1, ZEND_AST_ARRAY_PATTERN_ELEMENT_LIST, $1); }
+	|	array_pattern_element_list ',' array_pattern_element { $$ = zend_ast_list_add($1, $3); }
+;
+
+array_pattern_element:
+		pattern { $$ = zend_ast_create(ZEND_AST_ARRAY_PATTERN_ELEMENT, NULL, $1); }
+	|	scalar_pattern T_DOUBLE_ARROW pattern
+			 { $$ = zend_ast_create(ZEND_AST_ARRAY_PATTERN_ELEMENT, $1, $3); }
+;
+
+class_const_pattern:
+		class_name T_PAAMAYIM_NEKUDOTAYIM identifier
+			{ $$ = zend_ast_create(ZEND_AST_CLASS_CONST_PATTERN, $1, $3); }
+;
 
 inline_function:
 		function returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars return_type
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 3ecb2f8d0ee45..bc57f192c654e 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -1518,6 +1518,10 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN_WITH_IDENT(T_MATCH);
 }
 
+<ST_IN_SCRIPTING>"is" {
+	RETURN_TOKEN_WITH_IDENT(T_IS);
+}
+
 <ST_IN_SCRIPTING>"endswitch" {
 	RETURN_TOKEN_WITH_IDENT(T_ENDSWITCH);
 }
@@ -1618,6 +1622,14 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_
 	RETURN_TOKEN(T_ELLIPSIS);
 }
 
+<ST_IN_SCRIPTING>"..<" {
+	RETURN_TOKEN(T_RANGE_EXCLUSIVE_END);
+}
+
+<ST_IN_SCRIPTING>"..=" {
+	RETURN_TOKEN(T_RANGE_INCLUSIVE_END);
+}
+
 <ST_IN_SCRIPTING>"??" {
 	RETURN_TOKEN(T_COALESCE);
 }
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 1962c7b5a56d1..7d7039c0c2be3 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -903,7 +903,8 @@ static bool keeps_op1_alive(zend_op *opline) {
 	 || opline->opcode == ZEND_FETCH_LIST_R
 	 || opline->opcode == ZEND_FETCH_LIST_W
 	 || opline->opcode == ZEND_COPY_TMP
-	 || opline->opcode == ZEND_EXT_STMT) {
+	 || opline->opcode == ZEND_EXT_STMT
+	 || opline->opcode == ZEND_IS) {
 		return true;
 	}
 	ZEND_ASSERT(opline->opcode != ZEND_FE_FETCH_R
@@ -991,7 +992,8 @@ static void zend_calc_live_ranges(
 		if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
 			uint32_t var_num = EX_VAR_TO_NUM(opline->op2.var) - var_offset;
 			if (UNEXPECTED(opline->opcode == ZEND_FE_FETCH_R
-					|| opline->opcode == ZEND_FE_FETCH_RW)) {
+					|| opline->opcode == ZEND_FE_FETCH_RW
+					|| opline->opcode == ZEND_IS)) {
 				/* OP2 of FE_FETCH is actually a def, not a use. */
 				if (last_use[var_num] != (uint32_t) -1) {
 					if (opnum + 1 != last_use[var_num]) {
@@ -1196,6 +1198,9 @@ ZEND_API void pass_two(zend_op_array *op_array)
 				opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
 				break;
 			}
+			case ZEND_IS:
+				opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value);
+				break;
 		}
 		if (opline->op1_type == IS_CONST) {
 			ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline, opline->op1);
diff --git a/Zend/zend_pattern_matching.c b/Zend/zend_pattern_matching.c
new file mode 100644
index 0000000000000..40b2c3ce7a87b
--- /dev/null
+++ b/Zend/zend_pattern_matching.c
@@ -0,0 +1,281 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 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.              |
+   +----------------------------------------------------------------------+
+*/
+
+#include "zend_pattern_matching.h"
+#include "zend_API.h"
+#include "zend_compile.h"
+#include "zend_execute.h"
+#include "zend_exceptions.h"
+#include "zend_type_info.h"
+#include "zend_constants.h"
+
+typedef enum {
+	PM_ERROR = -1,
+	PM_MISMATCH = 0,
+	PM_MATCH = 1,
+} pm_result;
+
+typedef struct {
+	zend_array *bindings;
+} pm_context;
+
+pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern, pm_context *context);
+static zend_class_entry *get_class_from_fetch_type(uint32_t fetch_type);
+
+static pm_result match_type(zval *zv, zend_ast *type_ast)
+{
+	zend_ast *class_name_ast = type_ast->child[0];
+	uint32_t fetch_type;
+
+	if (class_name_ast) {
+		if (Z_TYPE_P(zv) != IS_OBJECT) {
+			return PM_MISMATCH;
+		}
+
+		zend_string *class_name = zend_ast_get_str(class_name_ast);
+		fetch_type = zend_get_class_fetch_type(class_name);
+
+		zend_class_entry *expected_class = NULL;
+		if (fetch_type == ZEND_FETCH_CLASS_DEFAULT) {
+			zend_object *obj = Z_OBJ_P(zv);
+			if (zend_string_equals_ci(obj->ce->name, class_name)) {
+				return PM_MATCH;
+			}
+			expected_class = zend_lookup_class_ex(class_name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
+		} else {
+non_default_fetch_type:
+			expected_class = get_class_from_fetch_type(fetch_type);
+			if (!expected_class) {
+				return PM_ERROR;
+			}
+		}
+		if (!expected_class || !instanceof_function(Z_OBJ_P(zv)->ce, expected_class)) {
+			return PM_MISMATCH;
+		}
+	} else {
+		zend_type type = ZEND_TYPE_INIT_MASK(type_ast->attr);
+		if (!ZEND_TYPE_CONTAINS_CODE(type, Z_TYPE_P(zv))) {
+			if (ZEND_TYPE_CONTAINS_CODE(type, IS_STATIC)) {
+				fetch_type = ZEND_FETCH_CLASS_STATIC;
+				goto non_default_fetch_type;
+			}
+			return PM_MISMATCH;
+		}
+	}
+
+	return PM_MATCH;
+}
+
+static bool match_zval(zval *lhs, zval *rhs)
+{
+	return zend_is_identical(lhs, rhs);
+}
+
+static zend_class_entry *get_class_from_fetch_type(uint32_t fetch_type)
+{
+	zend_class_entry *scope;
+
+	switch (fetch_type) {
+		case ZEND_FETCH_CLASS_SELF:
+			scope = zend_get_executed_scope();
+			if (UNEXPECTED(!scope)) {
+				zend_throw_error(NULL, "%s", "Cannot access \"self\" when no class scope is active");
+				return NULL;
+			}
+			return scope;
+		case ZEND_FETCH_CLASS_PARENT:
+			scope = zend_get_executed_scope();
+			if (UNEXPECTED(!scope)) {
+				zend_throw_error(NULL, "%s", "Cannot access \"parent\" when no class scope is active");
+				return NULL;
+			}
+			scope = scope->parent;
+			if (UNEXPECTED(!scope)) {
+				zend_throw_error(NULL, "%s", "Cannot access \"parent\" when current class scope has no parent");
+				return NULL;
+			}
+			return scope;
+		case ZEND_FETCH_CLASS_STATIC:
+			scope = zend_get_called_scope(EG(current_execute_data));
+			if (UNEXPECTED(!scope)) {
+				zend_throw_error(NULL, "%s", "Cannot access \"static\" when no class scope is active");
+				return NULL;
+			}
+			return scope;
+		EMPTY_SWITCH_DEFAULT_CASE();
+	}
+
+	return NULL;
+}
+
+static pm_result match_object(zval *zv, zend_ast *pattern, pm_context *context)
+{
+	if (Z_TYPE_P(zv) != IS_OBJECT) {
+		return PM_MISMATCH;
+	}
+
+	zend_object *obj = Z_OBJ_P(zv);
+	zend_ast_list *elements = zend_ast_get_list(pattern->child[0]);
+	for (uint32_t i = 0; i < elements->children; i++) {
+		zend_ast *element = elements->child[i];
+		zend_ast *property_or_method_call = element->child[0];
+		zend_ast *element_pattern = element->child[1];
+		zend_string *property_name = zend_ast_get_str(property_or_method_call);
+		zval property_result_rv;
+		zval *property_result = obj->handlers->read_property(obj, property_name, BP_VAR_R, NULL, &property_result_rv);
+		pm_result element_matched = zend_pattern_match_ex(property_result, element_pattern, context);
+		if (property_result == &property_result_rv) {
+			zval_ptr_dtor(property_result);
+		}
+		if (element_matched != PM_MATCH) {
+			return element_matched;
+		}
+	}
+
+	return PM_MATCH;
+}
+
+static pm_result match_range(zval *zv, zend_ast *pattern)
+{
+	zval *start = zend_ast_get_zval(pattern->child[0]);
+	zval *end = zend_ast_get_zval(pattern->child[1]);
+
+	if (Z_TYPE_P(zv) != Z_TYPE_P(start) && zend_compare(zv, start) == -1) {
+		return PM_MISMATCH;
+	}
+
+	int end_check = zend_compare(zv, end);
+	if (Z_TYPE_P(zv) != Z_TYPE_P(end) || end_check == 1 || (!(pattern->attr & ZEND_AST_RANGE_INCLUSIVE_END) && end_check == 0)) {
+		return PM_MISMATCH;
+	}
+
+	return PM_MATCH;
+}
+
+static pm_result match_binding(zval *zv, zend_ast *pattern, pm_context *context)
+{
+	ZVAL_DEREF(zv);
+	Z_TRY_ADDREF_P(zv);
+	zend_hash_index_add(context->bindings, (zend_ulong) pattern->attr, zv);
+	return PM_MATCH;
+}
+
+static pm_result match_array(zval *zv, zend_ast *pattern, pm_context *context)
+{
+	if (Z_TYPE_P(zv) != IS_ARRAY) {
+		return PM_MISMATCH;
+	}
+
+	HashTable *ht = Z_ARRVAL_P(zv);
+	zend_ast_list *element_list = zend_ast_get_list(pattern->child[0]);
+
+	if (pattern->attr & ZEND_ARRAY_PATTERN_NON_EXHAUSTIVE) {
+		if (element_list->children > zend_hash_num_elements(ht)) {
+			return PM_MISMATCH;
+		}
+	} else {
+		if (element_list->children != zend_hash_num_elements(ht)) {
+			return PM_MISMATCH;
+		}
+	}
+
+	/* Explicit and implicit keys may not be mixed, so there's no need to
+	 * replicate array key sequencing logic. */
+	zend_long index = 0;
+
+	for (uint32_t i = 0; i < element_list->children; i++) {
+		zend_ast *element = element_list->child[i];
+		zend_ast *key_ast = element->child[0];
+		zend_ast *pattern_ast = element->child[1];
+		zval *element_zv;
+		if (key_ast) {
+			zval *key_zv = zend_ast_get_zval(key_ast);
+			if (Z_TYPE_P(key_zv) == IS_LONG) {
+				element_zv = zend_hash_index_find(ht, Z_LVAL_P(key_zv));
+			} else {
+				ZEND_ASSERT(Z_TYPE_P(key_zv) == IS_STRING);
+				element_zv = zend_hash_find(ht, Z_STR_P(key_zv));
+			}
+		} else {
+			element_zv = zend_hash_index_find(ht, index);
+			index++;
+		}
+		if (!element_zv || Z_TYPE_P(element_zv) == IS_UNDEF || !zend_pattern_match_ex(element_zv, pattern_ast, context)) {
+			return PM_MISMATCH;
+		}
+	}
+
+	return PM_MATCH;
+}
+
+pm_result match_class_const(zval *zv, zend_ast *pattern)
+{
+	zend_string *class_name = !pattern->attr
+		? zend_ast_get_str(pattern->child[0])
+		: NULL;
+	zend_string *constant_name = zend_ast_get_str(pattern->child[1]);
+	zval *constant_zv = zend_get_class_constant_ex(class_name, constant_name, zend_get_executed_scope(), pattern->attr);
+	if (EG(exception)) {
+		return PM_ERROR;
+	}
+	return zend_is_identical(zv, constant_zv) ? PM_MATCH : PM_MISMATCH;
+}
+
+pm_result zend_pattern_match_ex(zval *zv, zend_ast *pattern, pm_context *context)
+{
+	ZVAL_DEREF(zv);
+
+	switch (pattern->kind) {
+		case ZEND_AST_TYPE_PATTERN:
+			return match_type(zv, pattern);
+		case ZEND_AST_ZVAL:
+			return match_zval(zv, zend_ast_get_zval(pattern));
+		case ZEND_AST_OBJECT_PATTERN:
+			return match_object(zv, pattern, context);
+		case ZEND_AST_WILDCARD_PATTERN:
+			return PM_MATCH;
+		case ZEND_AST_OR_PATTERN: {
+			pm_result lhs = zend_pattern_match_ex(zv, pattern->child[0], context);
+			if (lhs != PM_MISMATCH) {
+				return lhs;
+			}
+			return zend_pattern_match_ex(zv, pattern->child[1], context);
+		}
+		case ZEND_AST_AND_PATTERN: {
+			pm_result lhs = zend_pattern_match_ex(zv, pattern->child[0], context);
+			if (lhs != PM_MATCH) {
+				return lhs;
+			}
+			return zend_pattern_match_ex(zv, pattern->child[1], context);
+		}
+		case ZEND_AST_RANGE_PATTERN:
+			return match_range(zv, pattern);
+		case ZEND_AST_BINDING_PATTERN:
+			return match_binding(zv, pattern, context);
+		case ZEND_AST_ARRAY_PATTERN:
+			return match_array(zv, pattern, context);
+		case ZEND_AST_CLASS_CONST_PATTERN:
+			return match_class_const(zv, pattern);
+		EMPTY_SWITCH_DEFAULT_CASE();
+	}
+}
+
+bool zend_pattern_match(zval *zv, zend_ast *pattern, zend_array *bindings)
+{
+	pm_context context = { .bindings = bindings };
+	pm_result result = zend_pattern_match_ex(zv, pattern, &context);
+	return result == PM_MATCH;
+}
diff --git a/Zend/zend_pattern_matching.h b/Zend/zend_pattern_matching.h
new file mode 100644
index 0000000000000..4bb3616547226
--- /dev/null
+++ b/Zend/zend_pattern_matching.h
@@ -0,0 +1,24 @@
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 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.              |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef ZEND_PATTERN_MATCHING_H
+#define ZEND_PATTERN_MATCHING_H
+
+#include "zend.h"
+
+bool zend_pattern_match(zval *zv, zend_ast *pattern, zend_array *bindings);
+
+#endif
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 07a0ecf1e2631..4d19ed882b095 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -9398,6 +9398,32 @@ ZEND_VM_C_LABEL(default_branch):
 	}
 }
 
+ZEND_VM_HANDLER(211, ZEND_IS, ANY, TMPVAR, JMP_ADDR)
+{
+	// , SPEC(OP_DATA=CONST)
+	USE_OPLINE
+	SAVE_OPLINE();
+	zval *expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	zend_array *bindings = NULL;
+	if ((opline+1)->extended_value) {
+		bindings = zend_new_array((opline+1)->extended_value);
+		zend_hash_real_init_packed(bindings);
+		ZVAL_ARR(EX_VAR(opline->op2.var), bindings);
+	}
+	zval *pattern = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
+	bool result = zend_pattern_match(expr, Z_ASTVAL_P(pattern), bindings);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	if (result) {
+		ZEND_VM_NEXT_OPCODE_EX(1, 2);
+	} else {
+		if (UNEXPECTED(EG(exception))) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	}
+}
+
 ZEND_VM_COLD_CONST_HANDLER(197, ZEND_MATCH_ERROR, CONST|TMPVARCV, UNUSED)
 {
 	USE_OPLINE
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index a6b79495d7c03..b5a41dfcacf29 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4308,6 +4308,32 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_DYNAMIC_
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	// , SPEC(OP_DATA=CONST)
+	USE_OPLINE
+	SAVE_OPLINE();
+	zval *expr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
+	zend_array *bindings = NULL;
+	if ((opline+1)->extended_value) {
+		bindings = zend_new_array((opline+1)->extended_value);
+		zend_hash_real_init_packed(bindings);
+		ZVAL_ARR(EX_VAR(opline->op2.var), bindings);
+	}
+	zval *pattern = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
+	bool result = zend_pattern_match(expr, Z_ASTVAL_P(pattern), bindings);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	if (result) {
+		ZEND_VM_NEXT_OPCODE_EX(1, 2);
+	} else {
+		if (UNEXPECTED(EG(exception))) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	}
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -59976,6 +60002,32 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_DYNAMIC_CALL_
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }
 
+static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	// , SPEC(OP_DATA=CONST)
+	USE_OPLINE
+	SAVE_OPLINE();
+	zval *expr = get_zval_ptr(opline->op1_type, opline->op1, BP_VAR_R);
+	zend_array *bindings = NULL;
+	if ((opline+1)->extended_value) {
+		bindings = zend_new_array((opline+1)->extended_value);
+		zend_hash_real_init_packed(bindings);
+		ZVAL_ARR(EX_VAR(opline->op2.var), bindings);
+	}
+	zval *pattern = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
+	bool result = zend_pattern_match(expr, Z_ASTVAL_P(pattern), bindings);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	if (result) {
+		ZEND_VM_NEXT_OPCODE_EX(1, 2);
+	} else {
+		if (UNEXPECTED(EG(exception))) {
+			HANDLE_EXCEPTION();
+		}
+		ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value);
+		ZEND_VM_CONTINUE();
+	}
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RECV_SPEC_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -115257,6 +115309,7 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL,
 			(void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL,
 			(void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL,
+			(void*)&&ZEND_IS_SPEC_TMPVAR_LABEL,
 			(void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL,
 			(void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL,
 			(void*)&&ZEND_NULL_LABEL,
@@ -116671,6 +116724,11 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 				ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR)
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_IS_SPEC_TMPVAR):
+				VM_TRACE(ZEND_IS_SPEC_TMPVAR)
+				ZEND_IS_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				VM_TRACE_OP_END(ZEND_IS_SPEC_TMPVAR)
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_RECV_SPEC_UNUSED):
 				VM_TRACE(ZEND_RECV_SPEC_UNUSED)
 				ZEND_RECV_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -124508,6 +124566,7 @@ void zend_vm_init(void)
 		ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER,
 		ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER,
 		ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER,
+		ZEND_IS_SPEC_TMPVAR_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_HANDLER,
 		ZEND_NULL_HANDLER,
@@ -128005,6 +128064,7 @@ void zend_vm_init(void)
 		ZEND_JMP_FRAMELESS_SPEC_CONST_TAILCALL_HANDLER,
 		ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER,
 		ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_TAILCALL_HANDLER,
+		ZEND_IS_SPEC_TMPVAR_TAILCALL_HANDLER,
 		ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER,
 		ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER,
 		ZEND_NULL_TAILCALL_HANDLER,
@@ -128973,7 +129033,7 @@ void zend_vm_init(void)
 		1255,
 		1256 | SPEC_RULE_OP1,
 		1261 | SPEC_RULE_OP1,
-		3493,
+		3494,
 		1266 | SPEC_RULE_OP1,
 		1271 | SPEC_RULE_OP1,
 		1276 | SPEC_RULE_OP2,
@@ -129007,7 +129067,7 @@ void zend_vm_init(void)
 		1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1584 | SPEC_RULE_OP1,
 		1589,
-		3493,
+		3494,
 		1590 | SPEC_RULE_OP1,
 		1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
 		1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2,
@@ -129139,51 +129199,51 @@ void zend_vm_init(void)
 		2575,
 		2576,
 		2577,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
-		3493,
+		2578,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
+		3494,
 	};
 #if 0
 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
@@ -129360,7 +129420,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2587 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -129368,7 +129428,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2612 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -129376,7 +129436,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2637 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 				if (op->op1_type < op->op2_type) {
 					zend_swap_operands(op);
 				}
@@ -129387,17 +129447,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2662 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			} else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2687 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 2712 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_MUL:
@@ -129408,17 +129468,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2737 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2762 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 2787 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_IDENTICAL:
@@ -129429,16 +129489,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2812 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2887 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
-				spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3112 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
-				spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3118 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_IDENTICAL:
@@ -129449,16 +129509,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2962 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3037 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) {
-				spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3115 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) {
-				spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
+				spec = 3123 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_EQUAL:
@@ -129469,12 +129529,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2812 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2887 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_NOT_EQUAL:
@@ -129485,12 +129545,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 2962 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
+				spec = 3037 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE;
 			}
 			break;
 		case ZEND_IS_SMALLER:
@@ -129498,12 +129558,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3128 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3203 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_IS_SMALLER_OR_EQUAL:
@@ -129511,79 +129571,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3278 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			} else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) {
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
+				spec = 3353 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH;
 			}
 			break;
 		case ZEND_QM_ASSIGN:
 			if (op1_info == MAY_BE_LONG) {
-				spec = 3439 | SPEC_RULE_OP1;
+				spec = 3440 | SPEC_RULE_OP1;
 			} else if (op1_info == MAY_BE_DOUBLE) {
-				spec = 3444 | SPEC_RULE_OP1;
+				spec = 3445 | SPEC_RULE_OP1;
 			} else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) {
-				spec = 3449 | SPEC_RULE_OP1;
+				spec = 3450 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_PRE_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3427 | SPEC_RULE_RETVAL;
+				spec = 3428 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3429 | SPEC_RULE_RETVAL;
+				spec = 3430 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_PRE_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3431 | SPEC_RULE_RETVAL;
+				spec = 3432 | SPEC_RULE_RETVAL;
 			} else if (op1_info == MAY_BE_LONG) {
-				spec = 3433 | SPEC_RULE_RETVAL;
+				spec = 3434 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_POST_INC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3435;
-			} else if (op1_info == MAY_BE_LONG) {
 				spec = 3436;
+			} else if (op1_info == MAY_BE_LONG) {
+				spec = 3437;
 			}
 			break;
 		case ZEND_POST_DEC:
 			if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) {
-				spec = 3437;
-			} else if (op1_info == MAY_BE_LONG) {
 				spec = 3438;
+			} else if (op1_info == MAY_BE_LONG) {
+				spec = 3439;
 			}
 			break;
 		case ZEND_JMP:
 			if (OP_JMP_ADDR(op, op->op1) > op) {
-				spec = 2585;
+				spec = 2586;
 			}
 			break;
 		case ZEND_INIT_FCALL:
 			if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) {
-				spec = 2578;
+				spec = 2579;
 			}
 			break;
 		case ZEND_RECV:
 			if (op->op2.num == MAY_BE_ANY) {
-				spec = 2579;
+				spec = 2580;
 			}
 			break;
 		case ZEND_SEND_VAL:
 			if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-				spec = 3489;
+				spec = 3490;
 			}
 			break;
 		case ZEND_SEND_VAR_EX:
 			if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3484 | SPEC_RULE_OP1;
+				spec = 3485 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_FE_FETCH_R:
 			if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) {
-				spec = 3491 | SPEC_RULE_RETVAL;
+				spec = 3492 | SPEC_RULE_RETVAL;
 			}
 			break;
 		case ZEND_FETCH_DIM_R:
@@ -129591,22 +129651,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t
 				if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) {
 					break;
 				}
-				spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
+				spec = 3455 | SPEC_RULE_OP1 | SPEC_RULE_OP2;
 			}
 			break;
 		case ZEND_SEND_VAL_EX:
 			if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) {
-				spec = 3490;
+				spec = 3491;
 			}
 			break;
 		case ZEND_SEND_VAR:
 			if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) {
-				spec = 3479 | SPEC_RULE_OP1;
+				spec = 3480 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_COUNT:
 			if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) {
-				spec = 2580 | SPEC_RULE_OP1;
+				spec = 2581 | SPEC_RULE_OP1;
 			}
 			break;
 		case ZEND_BW_OR:
diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h
index 33d951141550e..e37251180f40e 100644
--- a/Zend/zend_vm_handlers.h
+++ b/Zend/zend_vm_handlers.h
@@ -1373,508 +1373,509 @@
 	_(2575, ZEND_JMP_FRAMELESS_SPEC_CONST) \
 	_(2576, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED) \
 	_(2577, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST) \
-	_(2578, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
-	_(2579, ZEND_RECV_NOTYPE_SPEC) \
-	_(2581, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2578, ZEND_IS_SPEC_TMPVAR) \
+	_(2579, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \
+	_(2580, ZEND_RECV_NOTYPE_SPEC) \
 	_(2582, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
-	_(2584, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
-	_(2585, ZEND_JMP_FORWARD_SPEC) \
-	_(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2583, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \
+	_(2585, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \
+	_(2586, ZEND_JMP_FORWARD_SPEC) \
+	_(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2594, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2596, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2597, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2598, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2600, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2606, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2599, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2607, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2608, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2610, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2609, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
 	_(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2619, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2621, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2622, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
 	_(2623, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2625, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2631, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
-	_(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2624, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2632, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \
 	_(2633, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2635, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2634, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2644, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2646, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2647, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2648, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2650, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2656, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2649, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2657, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2658, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2660, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2659, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
-	_(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2664, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \
+	_(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2669, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2671, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2672, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2673, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2675, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2681, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2674, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2687, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2684, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
 	_(2688, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2690, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
-	_(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2689, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2691, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \
+	_(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
 	_(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2694, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2696, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2697, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
 	_(2698, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2700, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2706, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
-	_(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2699, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2707, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \
 	_(2708, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2710, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2712, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2709, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \
 	_(2713, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2715, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2714, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2716, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2719, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2721, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2722, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2723, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2725, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2731, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2724, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2732, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2733, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2735, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2734, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2744, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2746, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2747, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2748, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2750, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2756, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
-	_(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2749, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2757, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \
 	_(2758, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2760, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
-	_(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2759, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \
+	_(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
 	_(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2769, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2771, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2772, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
 	_(2773, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2775, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2781, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2774, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2782, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \
 	_(2783, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2785, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2784, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2794, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2796, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2797, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2798, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2800, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2806, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2799, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2807, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \
 	_(2808, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2810, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2883, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2958, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3033, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3108, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3111, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
-	_(3112, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3113, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3114, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
-	_(3115, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3116, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3117, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3121, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3122, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
-	_(3126, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
-	_(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3139, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
-	_(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3142, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3187, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
-	_(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3199, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3262, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3274, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
-	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3337, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
-	_(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3349, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
-	_(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
-	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
-	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
-	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3412, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
-	_(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
-	_(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
-	_(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3424, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
-	_(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
-	_(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3427, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3428, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3429, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3430, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3431, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3432, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3433, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3434, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3435, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3436, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3437, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3438, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3439, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
-	_(3440, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(2809, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2830, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2831, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2832, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2845, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2855, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2856, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2876, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2877, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2884, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2885, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2886, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2905, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2906, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2907, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2920, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2930, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2931, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2951, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2952, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2959, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(2960, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2961, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2980, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2981, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2982, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(2995, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3005, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3006, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3026, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3027, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3034, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3035, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3036, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3055, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3056, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3057, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3070, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3080, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3081, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3101, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3102, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3109, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3110, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3111, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3112, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
+	_(3113, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3114, ZEND_IS_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3115, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST) \
+	_(3116, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3117, ZEND_IS_NOT_IDENTICAL_EMPTY_ARRAY_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3118, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3122, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3123, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \
+	_(3127, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \
+	_(3131, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3132, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3133, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3134, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3135, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3136, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3140, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \
+	_(3141, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3142, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3155, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3165, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3166, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \
+	_(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3191, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3192, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3193, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3194, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3195, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3196, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3200, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3215, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3216, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3217, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3240, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3241, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3266, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3267, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3268, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3269, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3270, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3271, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3275, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3290, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \
+	_(3291, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3292, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3315, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3316, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \
+	_(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3341, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3342, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3343, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3344, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3345, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3346, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3350, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \
+	_(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3365, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \
+	_(3366, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \
+	_(3367, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \
+	_(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3390, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3391, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \
+	_(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \
+	_(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \
+	_(3416, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3417, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3418, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3419, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3420, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3421, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3425, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
+	_(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
+	_(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
+	_(3428, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3429, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3430, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3431, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3432, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
+	_(3433, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
+	_(3434, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
+	_(3435, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
+	_(3436, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3437, ZEND_POST_INC_LONG_SPEC_CV) \
+	_(3438, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
+	_(3439, ZEND_POST_DEC_LONG_SPEC_CV) \
+	_(3440, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \
 	_(3441, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3443, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
-	_(3444, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
-	_(3445, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3442, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3444, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \
+	_(3445, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
 	_(3446, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3448, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
-	_(3449, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
-	_(3450, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3447, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3449, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
+	_(3450, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \
 	_(3451, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3453, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
-	_(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3452, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
+	_(3454, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \
 	_(3456, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3458, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
-	_(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3459, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \
+	_(3460, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
 	_(3461, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
-	_(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3462, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \
 	_(3466, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3468, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
-	_(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
-	_(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \
+	_(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \
 	_(3476, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
-	_(3481, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
-	_(3483, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
-	_(3486, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
-	_(3488, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
-	_(3489, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
-	_(3490, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
-	_(3491, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
-	_(3492, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
-	_(3492+1, ZEND_NULL)
+	_(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \
+	_(3482, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \
+	_(3484, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \
+	_(3487, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \
+	_(3489, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \
+	_(3490, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \
+	_(3491, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \
+	_(3492, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \
+	_(3493, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \
+	_(3493+1, ZEND_NULL)
diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c
index 936a96e55e41f..7546ef654d927 100644
--- a/Zend/zend_vm_opcodes.c
+++ b/Zend/zend_vm_opcodes.c
@@ -22,7 +22,7 @@
 #include <zend.h>
 #include <zend_vm_opcodes.h>
 
-static const char *zend_vm_opcodes_names[211] = {
+static const char *zend_vm_opcodes_names[212] = {
 	"ZEND_NOP",
 	"ZEND_ADD",
 	"ZEND_SUB",
@@ -234,9 +234,10 @@ static const char *zend_vm_opcodes_names[211] = {
 	"ZEND_JMP_FRAMELESS",
 	"ZEND_INIT_PARENT_PROPERTY_HOOK_CALL",
 	"ZEND_DECLARE_ATTRIBUTED_CONST",
+	"ZEND_IS",
 };
 
-static uint32_t zend_vm_opcodes_flags[211] = {
+static uint32_t zend_vm_opcodes_flags[212] = {
 	0x00000000,
 	0x00000b0b,
 	0x00000b0b,
@@ -448,6 +449,7 @@ static uint32_t zend_vm_opcodes_flags[211] = {
 	0x01042003,
 	0x01001103,
 	0x00000303,
+	0x03000500,
 };
 
 ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) {
diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 287dec375f3a9..dfa39cc251064 100644
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -330,7 +330,8 @@ END_EXTERN_C()
 #define ZEND_JMP_FRAMELESS                  208
 #define ZEND_INIT_PARENT_PROPERTY_HOOK_CALL 209
 #define ZEND_DECLARE_ATTRIBUTED_CONST       210
+#define ZEND_IS                             211
 
-#define ZEND_VM_LAST_OPCODE                 210
+#define ZEND_VM_LAST_OPCODE                 211
 
 #endif
diff --git a/configure.ac b/configure.ac
index 77fc8c89cdf40..91c3e903a3d48 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1779,6 +1779,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([
     zend_observer.c
     zend_opcode.c
     zend_operators.c
+    zend_pattern_matching.c
     zend_property_hooks.c
     zend_ptr_stack.c
     zend_signal.c
diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c
index 0900c51d3d95a..501bd213652ab 100644
--- a/ext/tokenizer/tokenizer_data.c
+++ b/ext/tokenizer/tokenizer_data.c
@@ -72,6 +72,7 @@ char *get_token_type_name(int token_type)
 		case T_CASE: return "T_CASE";
 		case T_DEFAULT: return "T_DEFAULT";
 		case T_MATCH: return "T_MATCH";
+		case T_IS: return "T_IS";
 		case T_BREAK: return "T_BREAK";
 		case T_CONTINUE: return "T_CONTINUE";
 		case T_GOTO: return "T_GOTO";
@@ -174,6 +175,8 @@ char *get_token_type_name(int token_type)
 		case T_POW: return "T_POW";
 		case T_POW_EQUAL: return "T_POW_EQUAL";
 		case T_PIPE: return "T_PIPE";
+		case T_RANGE_EXCLUSIVE_END: return "T_RANGE_EXCLUSIVE_END";
+		case T_RANGE_INCLUSIVE_END: return "T_RANGE_INCLUSIVE_END";
 		case T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG";
 		case T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG";
 		case T_BAD_CHARACTER: return "T_BAD_CHARACTER";
diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php
index 57c8edad8acb6..a8b04b8f75925 100644
--- a/ext/tokenizer/tokenizer_data.stub.php
+++ b/ext/tokenizer/tokenizer_data.stub.php
@@ -237,6 +237,11 @@
  * @cvalue T_MATCH
  */
 const T_MATCH = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_IS
+ */
+const T_IS = UNKNOWN;
 /**
  * @var int
  * @cvalue T_BREAK
@@ -747,6 +752,16 @@
  * @cvalue T_PIPE
  */
 const T_PIPE = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_RANGE_EXCLUSIVE_END
+ */
+const T_RANGE_EXCLUSIVE_END = UNKNOWN;
+/**
+ * @var int
+ * @cvalue T_RANGE_INCLUSIVE_END
+ */
+const T_RANGE_INCLUSIVE_END = UNKNOWN;
 /**
  * @var int
  * @cvalue T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG
diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h
index 3a3cdaa468133..4c0f76530b498 100644
--- a/ext/tokenizer/tokenizer_data_arginfo.h
+++ b/ext/tokenizer/tokenizer_data_arginfo.h
@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: c5235344b7c651d27c2c33c90696a418a9c96837 */
+ * Stub hash: 78c6192b937f5aad7c4b0b5a950935c9b59ef52a */
 
 static void register_tokenizer_data_symbols(int module_number)
 {
@@ -50,6 +50,7 @@ static void register_tokenizer_data_symbols(int module_number)
 	REGISTER_LONG_CONSTANT("T_CASE", T_CASE, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_DEFAULT", T_DEFAULT, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_MATCH", T_MATCH, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_IS", T_IS, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BREAK", T_BREAK, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_CONTINUE", T_CONTINUE, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_GOTO", T_GOTO, CONST_PERSISTENT);
@@ -152,6 +153,8 @@ static void register_tokenizer_data_symbols(int module_number)
 	REGISTER_LONG_CONSTANT("T_POW", T_POW, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_POW_EQUAL", T_POW_EQUAL, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_PIPE", T_PIPE, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RANGE_EXCLUSIVE_END", T_RANGE_EXCLUSIVE_END, CONST_PERSISTENT);
+	REGISTER_LONG_CONSTANT("T_RANGE_INCLUSIVE_END", T_RANGE_INCLUSIVE_END, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG", T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG, CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("T_BAD_CHARACTER", T_BAD_CHARACTER, CONST_PERSISTENT);
diff --git a/win32/build/config.w32 b/win32/build/config.w32
index 403f0aa6efbfe..ee40928727864 100644
--- a/win32/build/config.w32
+++ b/win32/build/config.w32
@@ -241,7 +241,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
 	zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \
 	zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c zend_system_id.c \
 	zend_enum.c zend_fibers.c zend_atomic.c zend_hrtime.c zend_frameless_function.c zend_property_hooks.c \
-	zend_lazy_objects.c");
+	zend_lazy_objects.c zend_pattern_matching.c");
 ADD_SOURCES("Zend\\Optimizer", "zend_optimizer.c pass1.c pass3.c optimize_func_calls.c block_pass.c optimize_temp_vars_5.c nop_removal.c compact_literals.c zend_cfg.c zend_dfg.c dfa_pass.c zend_ssa.c zend_inference.c zend_func_info.c zend_call_graph.c zend_dump.c escape_analysis.c compact_vars.c dce.c sccp.c scdf.c");
 
 var PHP_ASSEMBLER = PATH_PROG({