diff --git a/src/Type/TypeCombinator.php b/src/Type/TypeCombinator.php
index 3413ec6e8da..81059e849f8 100644
--- a/src/Type/TypeCombinator.php
+++ b/src/Type/TypeCombinator.php
@@ -41,7 +41,9 @@
 use function get_class;
 use function implode;
 use function in_array;
+use function is_bool;
 use function is_int;
+use function is_string;
 use function sprintf;
 use function usort;
 use const PHP_INT_MAX;
@@ -1498,6 +1500,98 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 		return array_merge($newArrays, $arraysToProcess);
 	}
 
+	/**
+	 * Fast path for intersect(): the intersection of two unions whose members are all
+	 * finite, mutually-disjoint values (constant scalars and/or enum cases) is their
+	 * identity-keyed set intersection. Returns null when either union has a member that is
+	 * not such a value, in which case the caller falls back to the general A & (B|C)
+	 * distribution.
+	 */
+	private static function intersectFiniteUnions(UnionType $a, UnionType $b): ?Type
+	{
+		$membersA = self::finiteUnionMembers($a);
+		if ($membersA === null) {
+			return null;
+		}
+
+		$membersB = self::finiteUnionMembers($b);
+		if ($membersB === null) {
+			return null;
+		}
+
+		$common = [];
+		foreach ($membersA as $key => $member) {
+			if (!array_key_exists($key, $membersB)) {
+				continue;
+			}
+
+			$common[] = $member;
+		}
+
+		if ($common === []) {
+			return new NeverType();
+		}
+
+		return self::union(...$common);
+	}
+
+	/**
+	 * Keys a union's members by identity for the finite-union fast path in intersect().
+	 *
+	 * Handles constant scalars and enum cases: each stands for one concrete value, so two
+	 * members are interchangeable iff they share a key and are otherwise disjoint. Returns
+	 * null if any member is not such a value. Class-string constant strings are excluded
+	 * (the class-string flag is not captured by the value) and floats are excluded (-0.0 /
+	 * NAN comparison quirks). Enum cases are keyed by class + case name, the identity
+	 * EnumCaseObjectType::equals() compares.
+	 *
+	 * @return array<string, Type>|null
+	 */
+	private static function finiteUnionMembers(UnionType $union): ?array
+	{
+		$members = [];
+		foreach ($union->getTypes() as $member) {
+			$enumCase = $member->getEnumCaseObject();
+			if ($member->isNull()->yes()) {
+				$key = 'null';
+			} elseif ($enumCase !== null) {
+				// getEnumCaseObject() also returns the case for a refined member - an
+				// intersection like $this & Enum::C, a whole single-case enum, or an enum
+				// subtracted to one case - none of which are a bare EnumCaseObjectType.
+				// Only a bare case is safe to key by class + case name; for the rest,
+				// EnumCaseObjectType::equals() is false (it requires an EnumCaseObjectType),
+				// so bail to the slow path rather than collapse the refinement.
+				if (!$enumCase->equals($member)) {
+					return null;
+				}
+
+				// Key by class + case name, the identity EnumCaseObjectType::equals() compares
+				// (describe() would also fold in a subtracted type, which equals() ignores).
+				$key = 'enum:' . $enumCase->getClassName() . '::' . $enumCase->getEnumCaseName();
+			} else {
+				$values = $member->getConstantScalarValues();
+				if (count($values) !== 1) {
+					return null;
+				}
+
+				$value = $values[0];
+				if (is_int($value)) {
+					$key = 'i:' . $value;
+				} elseif (is_bool($value)) {
+					$key = $value ? 'b:1' : 'b:0';
+				} elseif (is_string($value) && $member->isClassString()->no()) {
+					$key = 's:' . $value;
+				} else {
+					return null;
+				}
+			}
+
+			$members[$key] = $member;
+		}
+
+		return $members;
+	}
+
 	public static function intersect(Type ...$types): Type
 	{
 		$typesCount = count($types);
@@ -1516,6 +1610,22 @@ public static function intersect(Type ...$types): Type
 			}
 		}
 
+		// Fast path: the intersection of two plain unions whose members are all finite,
+		// mutually-disjoint values (constant scalars and/or enum cases) is their
+		// identity-keyed set intersection (O(n)), avoiding the O(n*m) `A & (B|C)`
+		// distribution + union rebuild below. Restricted to the exact UnionType class so
+		// BenevolentUnionType and the template union types keep their dedicated handling.
+		if (
+			$typesCount === 2
+			&& get_class($types[0]) === UnionType::class
+			&& get_class($types[1]) === UnionType::class
+		) {
+			$finiteIntersection = self::intersectFiniteUnions($types[0], $types[1]);
+			if ($finiteIntersection !== null) {
+				return $finiteIntersection;
+			}
+		}
+
 		$sortTypes = static function (Type $a, Type $b): int {
 			if (!$a instanceof UnionType || !$b instanceof UnionType) {
 				return 0;
diff --git a/tests/PHPStan/Type/TypeCombinatorTest.php b/tests/PHPStan/Type/TypeCombinatorTest.php
index c5499d47447..70c155b1b53 100644
--- a/tests/PHPStan/Type/TypeCombinatorTest.php
+++ b/tests/PHPStan/Type/TypeCombinatorTest.php
@@ -5632,6 +5632,133 @@ public static function dataIntersect(): iterable
 			ConstantArrayType::class,
 			'array{a: int}',
 		];
+
+		// intersection of two constant-scalar unions (constant-union fast path)
+		yield [
+			[
+				'0|1|2|3',
+				'2|3|4|5',
+			],
+			UnionType::class,
+			'2|3',
+		];
+
+		yield [
+			[
+				"'a'|'b'|'c'",
+				"'b'|'c'|'d'",
+			],
+			UnionType::class,
+			"'b'|'c'",
+		];
+
+		yield [
+			[
+				'1|2',
+				'3|4',
+			],
+			NeverType::class,
+			'*NEVER*=implicit',
+		];
+
+		yield [
+			[
+				'0|1',
+				'1|2',
+			],
+			ConstantIntegerType::class,
+			'1',
+		];
+
+		yield [
+			[
+				"0|1|'a'|'b'|null",
+				"1|2|'a'|'c'|null",
+			],
+			UnionType::class,
+			"1|'a'|null",
+		];
+
+		// a non-constant member makes the fast path bail to the normal distribution
+		yield [
+			[
+				'0|1|2|non-empty-string',
+				'1|2',
+			],
+			UnionType::class,
+			'1|2',
+		];
+
+		// finite-union fast path: enum-case unions
+		yield [
+			[
+				new UnionType([
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'ONE'),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'TWO'),
+					new EnumCaseObjectType('PHPStan\Fixture\AnotherTestEnum', 'ONE'),
+				]),
+				new UnionType([
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'ONE'),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'TWO'),
+					new EnumCaseObjectType('PHPStan\Fixture\AnotherTestEnum', 'TWO'),
+				]),
+			],
+			UnionType::class,
+			'PHPStan\Fixture\TestEnum::ONE|PHPStan\Fixture\TestEnum::TWO',
+		];
+
+		// finite-union fast path: mixed constant scalars + enum cases
+		yield [
+			[
+				new UnionType([
+					new ConstantIntegerType(0),
+					new ConstantIntegerType(1),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'ONE'),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'TWO'),
+				]),
+				new UnionType([
+					new ConstantIntegerType(1),
+					new ConstantIntegerType(2),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'ONE'),
+				]),
+			],
+			UnionType::class,
+			'1|PHPStan\Fixture\TestEnum::ONE',
+		];
+
+		// a backed enum case (TestEnum::TWO = 2) must not be conflated with the integer 2
+		yield [
+			[
+				new UnionType([
+					new ConstantIntegerType(2),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'TWO'),
+				]),
+				new UnionType([
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'ONE'),
+					new EnumCaseObjectType('PHPStan\Fixture\TestEnum', 'TWO'),
+				]),
+			],
+			EnumCaseObjectType::class,
+			'PHPStan\Fixture\TestEnum::TWO',
+		];
+
+		// a constant string '0'/'1' must not be conflated with the integer 0/1
+		yield [
+			[
+				new UnionType([
+					new ConstantIntegerType(0),
+					new ConstantStringType('0'),
+					new ConstantIntegerType(1),
+					new ConstantStringType('1'),
+				]),
+				new UnionType([
+					new ConstantStringType('0'),
+					new ConstantIntegerType(1),
+				]),
+			],
+			UnionType::class,
+			"1|'0'",
+		];
 	}
 
 	/**
diff --git a/tests/bench/data/bug-14869-enum.php b/tests/bench/data/bug-14869-enum.php
new file mode 100644
index 00000000000..21a7768bdad
--- /dev/null
+++ b/tests/bench/data/bug-14869-enum.php
@@ -0,0 +1,265 @@
+<?php
+
+namespace Bug14869Enum;
+
+/**
+ * Exercises the enum-case branch of the finite-union fast path in
+ * TypeCombinator::intersect().
+ *
+ * Assigning an enum case under many `$x === Enum::Case` branches over a large
+ * backed enum makes the conditional-expression machinery repeatedly intersect
+ * the growing enum-case union with the narrowed union. Before the fast path
+ * this was super-linear (~30s at N=400); keying members by class + case name
+ * turns each intersect into an O(n) set intersection. phpstan/phpstan#14869.
+ */
+
+enum E: int
+{
+	case C0 = 0;
+	case C1 = 1;
+	case C2 = 2;
+	case C3 = 3;
+	case C4 = 4;
+	case C5 = 5;
+	case C6 = 6;
+	case C7 = 7;
+	case C8 = 8;
+	case C9 = 9;
+	case C10 = 10;
+	case C11 = 11;
+	case C12 = 12;
+	case C13 = 13;
+	case C14 = 14;
+	case C15 = 15;
+	case C16 = 16;
+	case C17 = 17;
+	case C18 = 18;
+	case C19 = 19;
+	case C20 = 20;
+	case C21 = 21;
+	case C22 = 22;
+	case C23 = 23;
+	case C24 = 24;
+	case C25 = 25;
+	case C26 = 26;
+	case C27 = 27;
+	case C28 = 28;
+	case C29 = 29;
+	case C30 = 30;
+	case C31 = 31;
+	case C32 = 32;
+	case C33 = 33;
+	case C34 = 34;
+	case C35 = 35;
+	case C36 = 36;
+	case C37 = 37;
+	case C38 = 38;
+	case C39 = 39;
+	case C40 = 40;
+	case C41 = 41;
+	case C42 = 42;
+	case C43 = 43;
+	case C44 = 44;
+	case C45 = 45;
+	case C46 = 46;
+	case C47 = 47;
+	case C48 = 48;
+	case C49 = 49;
+	case C50 = 50;
+	case C51 = 51;
+	case C52 = 52;
+	case C53 = 53;
+	case C54 = 54;
+	case C55 = 55;
+	case C56 = 56;
+	case C57 = 57;
+	case C58 = 58;
+	case C59 = 59;
+	case C60 = 60;
+	case C61 = 61;
+	case C62 = 62;
+	case C63 = 63;
+	case C64 = 64;
+	case C65 = 65;
+	case C66 = 66;
+	case C67 = 67;
+	case C68 = 68;
+	case C69 = 69;
+	case C70 = 70;
+	case C71 = 71;
+	case C72 = 72;
+	case C73 = 73;
+	case C74 = 74;
+	case C75 = 75;
+	case C76 = 76;
+	case C77 = 77;
+	case C78 = 78;
+	case C79 = 79;
+	case C80 = 80;
+	case C81 = 81;
+	case C82 = 82;
+	case C83 = 83;
+	case C84 = 84;
+	case C85 = 85;
+	case C86 = 86;
+	case C87 = 87;
+	case C88 = 88;
+	case C89 = 89;
+	case C90 = 90;
+	case C91 = 91;
+	case C92 = 92;
+	case C93 = 93;
+	case C94 = 94;
+	case C95 = 95;
+	case C96 = 96;
+	case C97 = 97;
+	case C98 = 98;
+	case C99 = 99;
+	case C100 = 100;
+	case C101 = 101;
+	case C102 = 102;
+	case C103 = 103;
+	case C104 = 104;
+	case C105 = 105;
+	case C106 = 106;
+	case C107 = 107;
+	case C108 = 108;
+	case C109 = 109;
+	case C110 = 110;
+	case C111 = 111;
+	case C112 = 112;
+	case C113 = 113;
+	case C114 = 114;
+	case C115 = 115;
+	case C116 = 116;
+	case C117 = 117;
+	case C118 = 118;
+	case C119 = 119;
+}
+
+function enumChain(E $x): E
+{
+	$v = E::C0;
+	if ($x === E::C0) { $v = E::C0; }
+	if ($x === E::C1) { $v = E::C1; }
+	if ($x === E::C2) { $v = E::C2; }
+	if ($x === E::C3) { $v = E::C3; }
+	if ($x === E::C4) { $v = E::C4; }
+	if ($x === E::C5) { $v = E::C5; }
+	if ($x === E::C6) { $v = E::C6; }
+	if ($x === E::C7) { $v = E::C7; }
+	if ($x === E::C8) { $v = E::C8; }
+	if ($x === E::C9) { $v = E::C9; }
+	if ($x === E::C10) { $v = E::C10; }
+	if ($x === E::C11) { $v = E::C11; }
+	if ($x === E::C12) { $v = E::C12; }
+	if ($x === E::C13) { $v = E::C13; }
+	if ($x === E::C14) { $v = E::C14; }
+	if ($x === E::C15) { $v = E::C15; }
+	if ($x === E::C16) { $v = E::C16; }
+	if ($x === E::C17) { $v = E::C17; }
+	if ($x === E::C18) { $v = E::C18; }
+	if ($x === E::C19) { $v = E::C19; }
+	if ($x === E::C20) { $v = E::C20; }
+	if ($x === E::C21) { $v = E::C21; }
+	if ($x === E::C22) { $v = E::C22; }
+	if ($x === E::C23) { $v = E::C23; }
+	if ($x === E::C24) { $v = E::C24; }
+	if ($x === E::C25) { $v = E::C25; }
+	if ($x === E::C26) { $v = E::C26; }
+	if ($x === E::C27) { $v = E::C27; }
+	if ($x === E::C28) { $v = E::C28; }
+	if ($x === E::C29) { $v = E::C29; }
+	if ($x === E::C30) { $v = E::C30; }
+	if ($x === E::C31) { $v = E::C31; }
+	if ($x === E::C32) { $v = E::C32; }
+	if ($x === E::C33) { $v = E::C33; }
+	if ($x === E::C34) { $v = E::C34; }
+	if ($x === E::C35) { $v = E::C35; }
+	if ($x === E::C36) { $v = E::C36; }
+	if ($x === E::C37) { $v = E::C37; }
+	if ($x === E::C38) { $v = E::C38; }
+	if ($x === E::C39) { $v = E::C39; }
+	if ($x === E::C40) { $v = E::C40; }
+	if ($x === E::C41) { $v = E::C41; }
+	if ($x === E::C42) { $v = E::C42; }
+	if ($x === E::C43) { $v = E::C43; }
+	if ($x === E::C44) { $v = E::C44; }
+	if ($x === E::C45) { $v = E::C45; }
+	if ($x === E::C46) { $v = E::C46; }
+	if ($x === E::C47) { $v = E::C47; }
+	if ($x === E::C48) { $v = E::C48; }
+	if ($x === E::C49) { $v = E::C49; }
+	if ($x === E::C50) { $v = E::C50; }
+	if ($x === E::C51) { $v = E::C51; }
+	if ($x === E::C52) { $v = E::C52; }
+	if ($x === E::C53) { $v = E::C53; }
+	if ($x === E::C54) { $v = E::C54; }
+	if ($x === E::C55) { $v = E::C55; }
+	if ($x === E::C56) { $v = E::C56; }
+	if ($x === E::C57) { $v = E::C57; }
+	if ($x === E::C58) { $v = E::C58; }
+	if ($x === E::C59) { $v = E::C59; }
+	if ($x === E::C60) { $v = E::C60; }
+	if ($x === E::C61) { $v = E::C61; }
+	if ($x === E::C62) { $v = E::C62; }
+	if ($x === E::C63) { $v = E::C63; }
+	if ($x === E::C64) { $v = E::C64; }
+	if ($x === E::C65) { $v = E::C65; }
+	if ($x === E::C66) { $v = E::C66; }
+	if ($x === E::C67) { $v = E::C67; }
+	if ($x === E::C68) { $v = E::C68; }
+	if ($x === E::C69) { $v = E::C69; }
+	if ($x === E::C70) { $v = E::C70; }
+	if ($x === E::C71) { $v = E::C71; }
+	if ($x === E::C72) { $v = E::C72; }
+	if ($x === E::C73) { $v = E::C73; }
+	if ($x === E::C74) { $v = E::C74; }
+	if ($x === E::C75) { $v = E::C75; }
+	if ($x === E::C76) { $v = E::C76; }
+	if ($x === E::C77) { $v = E::C77; }
+	if ($x === E::C78) { $v = E::C78; }
+	if ($x === E::C79) { $v = E::C79; }
+	if ($x === E::C80) { $v = E::C80; }
+	if ($x === E::C81) { $v = E::C81; }
+	if ($x === E::C82) { $v = E::C82; }
+	if ($x === E::C83) { $v = E::C83; }
+	if ($x === E::C84) { $v = E::C84; }
+	if ($x === E::C85) { $v = E::C85; }
+	if ($x === E::C86) { $v = E::C86; }
+	if ($x === E::C87) { $v = E::C87; }
+	if ($x === E::C88) { $v = E::C88; }
+	if ($x === E::C89) { $v = E::C89; }
+	if ($x === E::C90) { $v = E::C90; }
+	if ($x === E::C91) { $v = E::C91; }
+	if ($x === E::C92) { $v = E::C92; }
+	if ($x === E::C93) { $v = E::C93; }
+	if ($x === E::C94) { $v = E::C94; }
+	if ($x === E::C95) { $v = E::C95; }
+	if ($x === E::C96) { $v = E::C96; }
+	if ($x === E::C97) { $v = E::C97; }
+	if ($x === E::C98) { $v = E::C98; }
+	if ($x === E::C99) { $v = E::C99; }
+	if ($x === E::C100) { $v = E::C100; }
+	if ($x === E::C101) { $v = E::C101; }
+	if ($x === E::C102) { $v = E::C102; }
+	if ($x === E::C103) { $v = E::C103; }
+	if ($x === E::C104) { $v = E::C104; }
+	if ($x === E::C105) { $v = E::C105; }
+	if ($x === E::C106) { $v = E::C106; }
+	if ($x === E::C107) { $v = E::C107; }
+	if ($x === E::C108) { $v = E::C108; }
+	if ($x === E::C109) { $v = E::C109; }
+	if ($x === E::C110) { $v = E::C110; }
+	if ($x === E::C111) { $v = E::C111; }
+	if ($x === E::C112) { $v = E::C112; }
+	if ($x === E::C113) { $v = E::C113; }
+	if ($x === E::C114) { $v = E::C114; }
+	if ($x === E::C115) { $v = E::C115; }
+	if ($x === E::C116) { $v = E::C116; }
+	if ($x === E::C117) { $v = E::C117; }
+	if ($x === E::C118) { $v = E::C118; }
+	if ($x === E::C119) { $v = E::C119; }
+
+	return $v;
+}
diff --git a/tests/bench/data/bug-14869.php b/tests/bench/data/bug-14869.php
new file mode 100644
index 00000000000..6fe64a30559
--- /dev/null
+++ b/tests/bench/data/bug-14869.php
@@ -0,0 +1,267 @@
+<?php
+
+namespace Bug14869;
+
+/**
+ * Exercises the constant-scalar-union fast path in TypeCombinator::intersect().
+ *
+ * Assigning a variable under many `$x === <const>` branches makes the
+ * conditional-expression machinery repeatedly intersect $v growing
+ * constant-value union with the narrowed union. Before the fast path this
+ * was super-linear (O(N^2.3), ~21s at N=400); the identity-keyed set
+ * intersection turns each intersect O(n). phpstan/phpstan#14869.
+ */
+
+function intChain(int $x): string
+{
+	$v = 0;
+	if ($x === 0) { $v = 0; }
+	if ($x === 1) { $v = 1; }
+	if ($x === 2) { $v = 2; }
+	if ($x === 3) { $v = 3; }
+	if ($x === 4) { $v = 4; }
+	if ($x === 5) { $v = 5; }
+	if ($x === 6) { $v = 6; }
+	if ($x === 7) { $v = 7; }
+	if ($x === 8) { $v = 8; }
+	if ($x === 9) { $v = 9; }
+	if ($x === 10) { $v = 10; }
+	if ($x === 11) { $v = 11; }
+	if ($x === 12) { $v = 12; }
+	if ($x === 13) { $v = 13; }
+	if ($x === 14) { $v = 14; }
+	if ($x === 15) { $v = 15; }
+	if ($x === 16) { $v = 16; }
+	if ($x === 17) { $v = 17; }
+	if ($x === 18) { $v = 18; }
+	if ($x === 19) { $v = 19; }
+	if ($x === 20) { $v = 20; }
+	if ($x === 21) { $v = 21; }
+	if ($x === 22) { $v = 22; }
+	if ($x === 23) { $v = 23; }
+	if ($x === 24) { $v = 24; }
+	if ($x === 25) { $v = 25; }
+	if ($x === 26) { $v = 26; }
+	if ($x === 27) { $v = 27; }
+	if ($x === 28) { $v = 28; }
+	if ($x === 29) { $v = 29; }
+	if ($x === 30) { $v = 30; }
+	if ($x === 31) { $v = 31; }
+	if ($x === 32) { $v = 32; }
+	if ($x === 33) { $v = 33; }
+	if ($x === 34) { $v = 34; }
+	if ($x === 35) { $v = 35; }
+	if ($x === 36) { $v = 36; }
+	if ($x === 37) { $v = 37; }
+	if ($x === 38) { $v = 38; }
+	if ($x === 39) { $v = 39; }
+	if ($x === 40) { $v = 40; }
+	if ($x === 41) { $v = 41; }
+	if ($x === 42) { $v = 42; }
+	if ($x === 43) { $v = 43; }
+	if ($x === 44) { $v = 44; }
+	if ($x === 45) { $v = 45; }
+	if ($x === 46) { $v = 46; }
+	if ($x === 47) { $v = 47; }
+	if ($x === 48) { $v = 48; }
+	if ($x === 49) { $v = 49; }
+	if ($x === 50) { $v = 50; }
+	if ($x === 51) { $v = 51; }
+	if ($x === 52) { $v = 52; }
+	if ($x === 53) { $v = 53; }
+	if ($x === 54) { $v = 54; }
+	if ($x === 55) { $v = 55; }
+	if ($x === 56) { $v = 56; }
+	if ($x === 57) { $v = 57; }
+	if ($x === 58) { $v = 58; }
+	if ($x === 59) { $v = 59; }
+	if ($x === 60) { $v = 60; }
+	if ($x === 61) { $v = 61; }
+	if ($x === 62) { $v = 62; }
+	if ($x === 63) { $v = 63; }
+	if ($x === 64) { $v = 64; }
+	if ($x === 65) { $v = 65; }
+	if ($x === 66) { $v = 66; }
+	if ($x === 67) { $v = 67; }
+	if ($x === 68) { $v = 68; }
+	if ($x === 69) { $v = 69; }
+	if ($x === 70) { $v = 70; }
+	if ($x === 71) { $v = 71; }
+	if ($x === 72) { $v = 72; }
+	if ($x === 73) { $v = 73; }
+	if ($x === 74) { $v = 74; }
+	if ($x === 75) { $v = 75; }
+	if ($x === 76) { $v = 76; }
+	if ($x === 77) { $v = 77; }
+	if ($x === 78) { $v = 78; }
+	if ($x === 79) { $v = 79; }
+	if ($x === 80) { $v = 80; }
+	if ($x === 81) { $v = 81; }
+	if ($x === 82) { $v = 82; }
+	if ($x === 83) { $v = 83; }
+	if ($x === 84) { $v = 84; }
+	if ($x === 85) { $v = 85; }
+	if ($x === 86) { $v = 86; }
+	if ($x === 87) { $v = 87; }
+	if ($x === 88) { $v = 88; }
+	if ($x === 89) { $v = 89; }
+	if ($x === 90) { $v = 90; }
+	if ($x === 91) { $v = 91; }
+	if ($x === 92) { $v = 92; }
+	if ($x === 93) { $v = 93; }
+	if ($x === 94) { $v = 94; }
+	if ($x === 95) { $v = 95; }
+	if ($x === 96) { $v = 96; }
+	if ($x === 97) { $v = 97; }
+	if ($x === 98) { $v = 98; }
+	if ($x === 99) { $v = 99; }
+	if ($x === 100) { $v = 100; }
+	if ($x === 101) { $v = 101; }
+	if ($x === 102) { $v = 102; }
+	if ($x === 103) { $v = 103; }
+	if ($x === 104) { $v = 104; }
+	if ($x === 105) { $v = 105; }
+	if ($x === 106) { $v = 106; }
+	if ($x === 107) { $v = 107; }
+	if ($x === 108) { $v = 108; }
+	if ($x === 109) { $v = 109; }
+	if ($x === 110) { $v = 110; }
+	if ($x === 111) { $v = 111; }
+	if ($x === 112) { $v = 112; }
+	if ($x === 113) { $v = 113; }
+	if ($x === 114) { $v = 114; }
+	if ($x === 115) { $v = 115; }
+	if ($x === 116) { $v = 116; }
+	if ($x === 117) { $v = 117; }
+	if ($x === 118) { $v = 118; }
+	if ($x === 119) { $v = 119; }
+
+	return (string) $v;
+}
+
+function stringChain(int $x): string
+{
+	$v = "";
+	if ($x === 0) { $v = "v0"; }
+	if ($x === 1) { $v = "v1"; }
+	if ($x === 2) { $v = "v2"; }
+	if ($x === 3) { $v = "v3"; }
+	if ($x === 4) { $v = "v4"; }
+	if ($x === 5) { $v = "v5"; }
+	if ($x === 6) { $v = "v6"; }
+	if ($x === 7) { $v = "v7"; }
+	if ($x === 8) { $v = "v8"; }
+	if ($x === 9) { $v = "v9"; }
+	if ($x === 10) { $v = "v10"; }
+	if ($x === 11) { $v = "v11"; }
+	if ($x === 12) { $v = "v12"; }
+	if ($x === 13) { $v = "v13"; }
+	if ($x === 14) { $v = "v14"; }
+	if ($x === 15) { $v = "v15"; }
+	if ($x === 16) { $v = "v16"; }
+	if ($x === 17) { $v = "v17"; }
+	if ($x === 18) { $v = "v18"; }
+	if ($x === 19) { $v = "v19"; }
+	if ($x === 20) { $v = "v20"; }
+	if ($x === 21) { $v = "v21"; }
+	if ($x === 22) { $v = "v22"; }
+	if ($x === 23) { $v = "v23"; }
+	if ($x === 24) { $v = "v24"; }
+	if ($x === 25) { $v = "v25"; }
+	if ($x === 26) { $v = "v26"; }
+	if ($x === 27) { $v = "v27"; }
+	if ($x === 28) { $v = "v28"; }
+	if ($x === 29) { $v = "v29"; }
+	if ($x === 30) { $v = "v30"; }
+	if ($x === 31) { $v = "v31"; }
+	if ($x === 32) { $v = "v32"; }
+	if ($x === 33) { $v = "v33"; }
+	if ($x === 34) { $v = "v34"; }
+	if ($x === 35) { $v = "v35"; }
+	if ($x === 36) { $v = "v36"; }
+	if ($x === 37) { $v = "v37"; }
+	if ($x === 38) { $v = "v38"; }
+	if ($x === 39) { $v = "v39"; }
+	if ($x === 40) { $v = "v40"; }
+	if ($x === 41) { $v = "v41"; }
+	if ($x === 42) { $v = "v42"; }
+	if ($x === 43) { $v = "v43"; }
+	if ($x === 44) { $v = "v44"; }
+	if ($x === 45) { $v = "v45"; }
+	if ($x === 46) { $v = "v46"; }
+	if ($x === 47) { $v = "v47"; }
+	if ($x === 48) { $v = "v48"; }
+	if ($x === 49) { $v = "v49"; }
+	if ($x === 50) { $v = "v50"; }
+	if ($x === 51) { $v = "v51"; }
+	if ($x === 52) { $v = "v52"; }
+	if ($x === 53) { $v = "v53"; }
+	if ($x === 54) { $v = "v54"; }
+	if ($x === 55) { $v = "v55"; }
+	if ($x === 56) { $v = "v56"; }
+	if ($x === 57) { $v = "v57"; }
+	if ($x === 58) { $v = "v58"; }
+	if ($x === 59) { $v = "v59"; }
+	if ($x === 60) { $v = "v60"; }
+	if ($x === 61) { $v = "v61"; }
+	if ($x === 62) { $v = "v62"; }
+	if ($x === 63) { $v = "v63"; }
+	if ($x === 64) { $v = "v64"; }
+	if ($x === 65) { $v = "v65"; }
+	if ($x === 66) { $v = "v66"; }
+	if ($x === 67) { $v = "v67"; }
+	if ($x === 68) { $v = "v68"; }
+	if ($x === 69) { $v = "v69"; }
+	if ($x === 70) { $v = "v70"; }
+	if ($x === 71) { $v = "v71"; }
+	if ($x === 72) { $v = "v72"; }
+	if ($x === 73) { $v = "v73"; }
+	if ($x === 74) { $v = "v74"; }
+	if ($x === 75) { $v = "v75"; }
+	if ($x === 76) { $v = "v76"; }
+	if ($x === 77) { $v = "v77"; }
+	if ($x === 78) { $v = "v78"; }
+	if ($x === 79) { $v = "v79"; }
+	if ($x === 80) { $v = "v80"; }
+	if ($x === 81) { $v = "v81"; }
+	if ($x === 82) { $v = "v82"; }
+	if ($x === 83) { $v = "v83"; }
+	if ($x === 84) { $v = "v84"; }
+	if ($x === 85) { $v = "v85"; }
+	if ($x === 86) { $v = "v86"; }
+	if ($x === 87) { $v = "v87"; }
+	if ($x === 88) { $v = "v88"; }
+	if ($x === 89) { $v = "v89"; }
+	if ($x === 90) { $v = "v90"; }
+	if ($x === 91) { $v = "v91"; }
+	if ($x === 92) { $v = "v92"; }
+	if ($x === 93) { $v = "v93"; }
+	if ($x === 94) { $v = "v94"; }
+	if ($x === 95) { $v = "v95"; }
+	if ($x === 96) { $v = "v96"; }
+	if ($x === 97) { $v = "v97"; }
+	if ($x === 98) { $v = "v98"; }
+	if ($x === 99) { $v = "v99"; }
+	if ($x === 100) { $v = "v100"; }
+	if ($x === 101) { $v = "v101"; }
+	if ($x === 102) { $v = "v102"; }
+	if ($x === 103) { $v = "v103"; }
+	if ($x === 104) { $v = "v104"; }
+	if ($x === 105) { $v = "v105"; }
+	if ($x === 106) { $v = "v106"; }
+	if ($x === 107) { $v = "v107"; }
+	if ($x === 108) { $v = "v108"; }
+	if ($x === 109) { $v = "v109"; }
+	if ($x === 110) { $v = "v110"; }
+	if ($x === 111) { $v = "v111"; }
+	if ($x === 112) { $v = "v112"; }
+	if ($x === 113) { $v = "v113"; }
+	if ($x === 114) { $v = "v114"; }
+	if ($x === 115) { $v = "v115"; }
+	if ($x === 116) { $v = "v116"; }
+	if ($x === 117) { $v = "v117"; }
+	if ($x === 118) { $v = "v118"; }
+	if ($x === 119) { $v = "v119"; }
+
+	return $v;
+}