diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php
index 85867200a20..2f7f4681837 100644
--- a/src/Analyser/MutatingScope.php
+++ b/src/Analyser/MutatingScope.php
@@ -104,6 +104,7 @@
 use Serializable;
 use Throwable;
 use function abs;
+use function array_diff_key;
 use function array_filter;
 use function array_key_exists;
 use function array_keys;
@@ -4421,20 +4422,101 @@ private function mergeWithVariableState(?self $otherScope, bool $preserveVacuous
 			$otherScope->nativeExpressionTypes,
 		);
 
+		$afterExtractCall = $this->afterExtractCall && $otherScope->afterExtractCall;
+
+		// Remembered calls whose type differs between the branches may merge into
+		// exactly what the call resolves to on its own - e.g. count($a) of
+		// int<3, max> and int<0, 2> merges into int<0, max>. Such an entry adds
+		// nothing and would shadow what later narrowing of $a implies for the call,
+		// so it is not written into the merged scope at all.
+		$callCandidates = self::findMergedCallCandidates($differingExpressionKeys, $mergedExpressionTypes);
+		$scope = ScopeOps::scopeWith(
+			$this,
+			$callCandidates === [] ? $mergedExpressionTypes : array_diff_key($mergedExpressionTypes, $callCandidates),
+			$callCandidates === [] ? $mergedNativeTypes : array_diff_key($mergedNativeTypes, $callCandidates),
+			$conditionalExpressions,
+			[],
+			[],
+			[],
+			$this->inFirstLevelStatement,
+			$afterExtractCall,
+		);
+		if ($callCandidates === []) {
+			/** @var static */
+			return $scope;
+		}
+
+		$uninformativeKeys = $scope->findUninformativeMergedCalls($callCandidates, $mergedNativeTypes);
+		if (count($uninformativeKeys) === count($callCandidates)) {
+			/** @var static */
+			return $scope;
+		}
+
 		/** @var static */
 		return ScopeOps::scopeWith(
 			$this,
-			$mergedExpressionTypes,
-			$mergedNativeTypes,
+			array_diff_key($mergedExpressionTypes, $uninformativeKeys),
+			array_diff_key($mergedNativeTypes, $uninformativeKeys),
 			$conditionalExpressions,
 			[],
 			[],
 			[],
 			$this->inFirstLevelStatement,
-			$this->afterExtractCall && $otherScope->afterExtractCall,
+			$afterExtractCall,
 		);
 	}
 
+	/**
+	 * Certain merged call expressions whose type differs between the merged branches.
+	 *
+	 * @param array<string, true> $differingExpressionKeys
+	 * @param array<string, ExpressionTypeHolder> $mergedExpressionTypes
+	 * @return array<string, ExpressionTypeHolder>
+	 */
+	private static function findMergedCallCandidates(array $differingExpressionKeys, array $mergedExpressionTypes): array
+	{
+		$candidates = [];
+		foreach (array_keys($differingExpressionKeys) as $exprString) {
+			$holder = $mergedExpressionTypes[$exprString] ?? null;
+			if ($holder === null || !$holder->getCertainty()->yes()) {
+				continue;
+			}
+			$expr = $holder->getExpr();
+			if (!$expr instanceof FuncCall && !$expr instanceof MethodCall && !$expr instanceof Expr\StaticCall) {
+				continue;
+			}
+			$candidates[$exprString] = $holder;
+		}
+
+		return $candidates;
+	}
+
+	/**
+	 * Called on the merged scope without the candidates: keys of candidates whose
+	 * merged type (and native type) is exactly what the call resolves to here.
+	 *
+	 * @param array<string, ExpressionTypeHolder> $candidates
+	 * @param array<string, ExpressionTypeHolder> $mergedNativeTypes
+	 * @return array<string, true>
+	 */
+	private function findUninformativeMergedCalls(array $candidates, array $mergedNativeTypes): array
+	{
+		$uninformativeKeys = [];
+		foreach ($candidates as $exprString => $holder) {
+			$expr = $holder->getExpr();
+			if (!$holder->getType()->equals($this->getType($expr))) {
+				continue;
+			}
+			$nativeHolder = $mergedNativeTypes[$exprString] ?? null;
+			if ($nativeHolder !== null && !$nativeHolder->getType()->equals($this->getNativeType($expr))) {
+				continue;
+			}
+			$uninformativeKeys[$exprString] = true;
+		}
+
+		return $uninformativeKeys;
+	}
+
 	/**
 	 * Drops the keys of class-constant fetches that resolve to their declared value.
 	 *
diff --git a/tests/PHPStan/Analyser/nsrt/bug-13750.php b/tests/PHPStan/Analyser/nsrt/bug-13750.php
new file mode 100644
index 00000000000..e0050153658
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/bug-13750.php
@@ -0,0 +1,131 @@
+<?php
+
+namespace Bug13750;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorld
+{
+	/** @param array<mixed> $arr */
+	public function forgetCount(array $arr): void
+	{
+		if (count($arr) > 2) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<3, max>', count($arr));
+		}
+		assertType('array<mixed>', $arr);
+		assertType('int<0, max>', count($arr));
+		if (count($arr, COUNT_RECURSIVE) > 2) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<1, max>', count($arr));
+		}
+	}
+
+}
+
+class Analogous
+{
+
+	/** @var array<int> */
+	private array $prop = [];
+
+	/** @param array<mixed> $arr */
+	public function notIdentical(array $arr): void
+	{
+		if (count($arr) > 2) {
+		}
+		assertType('int<0, max>', count($arr));
+		if ($arr !== []) {
+			assertType('int<1, max>', count($arr));
+			assertType('int<1, max>', sizeof($arr));
+		} else {
+			assertType('0', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function truthy(array $arr): void
+	{
+		if (count($arr) > 2) {
+		}
+		if ($arr) {
+			assertType('int<1, max>', count($arr));
+		}
+		if (!empty($arr)) {
+			assertType('int<1, max>', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function offsetChecks(array $arr): void
+	{
+		if (count($arr) > 2) {
+		}
+		if (isset($arr[0])) {
+			assertType('int<1, max>', count($arr));
+		}
+		if (array_key_exists('a', $arr)) {
+			assertType('int<1, max>', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function sizeofRecursive(array $arr): void
+	{
+		if (sizeof($arr) > 2) {
+		}
+		assertType('int<0, max>', sizeof($arr));
+		if (sizeof($arr, COUNT_RECURSIVE) > 2) {
+			assertType('int<1, max>', sizeof($arr));
+			assertType('int<1, max>', count($arr));
+		}
+		if (count($arr, COUNT_RECURSIVE) === 0) {
+			assertType('0', count($arr));
+		}
+	}
+
+	public function property(): void
+	{
+		if (count($this->prop) > 2) {
+		}
+		assertType('int<0, max>', count($this->prop));
+		if ($this->prop !== []) {
+			assertType('int<1, max>', count($this->prop));
+		}
+	}
+
+	public function strlen(string $s): void
+	{
+		if (strlen($s) > 2) {
+		}
+		assertType('int<0, max>', strlen($s));
+		if ($s !== '') {
+			assertType('int<1, max>', strlen($s));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function keepsInformativeMergedCount(array $arr): void
+	{
+		if (count($arr) === 0) {
+			return;
+		}
+		if (count($arr) > 5) {
+		}
+		assertType('int<1, max>', count($arr));
+		if (count($arr) > 2) {
+			assertType('int<3, max>', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function keepsNarrowerCount(array $arr): void
+	{
+		if (count($arr) > 2) {
+			if ($arr !== []) {
+				assertType('int<3, max>', count($arr));
+			}
+		}
+	}
+
+}
diff --git a/turbo-ext/src/MutatingScope.cpp b/turbo-ext/src/MutatingScope.cpp
index 1138b46ed9a..c1f2806aefd 100644
--- a/turbo-ext/src/MutatingScope.cpp
+++ b/turbo-ext/src/MutatingScope.cpp
@@ -8411,15 +8411,144 @@ class MutatingScope
 			return zv::Val();
 		}
 
+		bool afterExtractCall = slotBool(PT_MS_PROP_AFTER_EXTRACT_CALL) && theirAfterExtractCall;
+
+		/* merged calls no more precise than the call itself are never written
+		 * into the merged scope */
+		zv::Val callCandidates = findMergedCallCandidates(Z_ARRVAL_P(differing.raw()), Z_ARRVAL_P(mergedTypes));
+		if (UNEXPECTED(callCandidates.isUndef())) return zv::Val();
+		HashTable *candidateTable = Z_ARRVAL_P(callCandidates.raw());
+		uint32_t candidateCount = zend_hash_num_elements(candidateTable);
+		if (candidateCount == 0) {
+			return scopeWithTables(
+				Z_ARRVAL_P(mergedTypes),
+				Z_ARRVAL_P(mergedNativeTypes),
+				Z_ARRVAL_P(conditionalExpressions.raw()),
+				(HashTable *) &zend_empty_array,
+				(HashTable *) &zend_empty_array,
+				(HashTable *) &zend_empty_array,
+				slotBool(PT_MS_PROP_IN_FIRST_LEVEL_STATEMENT),
+				afterExtractCall);
+		}
+
+		zv::Arr withoutTypes = withoutKeys(Z_ARRVAL_P(mergedTypes), candidateTable);
+		zv::Arr withoutNativeTypes = withoutKeys(Z_ARRVAL_P(mergedNativeTypes), candidateTable);
+		zv::Val scope = scopeWithTables(
+			withoutTypes.table(),
+			withoutNativeTypes.table(),
+			Z_ARRVAL_P(conditionalExpressions.raw()),
+			(HashTable *) &zend_empty_array,
+			(HashTable *) &zend_empty_array,
+			(HashTable *) &zend_empty_array,
+			slotBool(PT_MS_PROP_IN_FIRST_LEVEL_STATEMENT),
+			afterExtractCall);
+		if (UNEXPECTED(scope.isUndef())) return zv::Val();
+
+		zv::Val uninformativeKeys = findUninformativeMergedCalls(scope, candidateTable, Z_ARRVAL_P(mergedNativeTypes));
+		if (UNEXPECTED(uninformativeKeys.isUndef())) return zv::Val();
+		if (zend_hash_num_elements(Z_ARRVAL_P(uninformativeKeys.raw())) == candidateCount) return scope;
+
+		zv::Arr prunedTypes = withoutKeys(Z_ARRVAL_P(mergedTypes), Z_ARRVAL_P(uninformativeKeys.raw()));
+		zv::Arr prunedNativeTypes = withoutKeys(Z_ARRVAL_P(mergedNativeTypes), Z_ARRVAL_P(uninformativeKeys.raw()));
 		return scopeWithTables(
-			Z_ARRVAL_P(mergedTypes),
-			Z_ARRVAL_P(mergedNativeTypes),
+			prunedTypes.table(),
+			prunedNativeTypes.table(),
 			Z_ARRVAL_P(conditionalExpressions.raw()),
 			(HashTable *) &zend_empty_array,
 			(HashTable *) &zend_empty_array,
 			(HashTable *) &zend_empty_array,
 			slotBool(PT_MS_PROP_IN_FIRST_LEVEL_STATEMENT),
-			slotBool(PT_MS_PROP_AFTER_EXTRACT_CALL) && theirAfterExtractCall);
+			afterExtractCall);
+	}
+
+	/* array_diff_key($table, $keys) */
+	static zv::Arr withoutKeys(HashTable *table, HashTable *keys)
+	{
+		zv::Arr result = zv::Arr::copyOfTable(table);
+		result.separate();
+		for (auto entry : zv::TableRef(keys)) {
+			zend_string *key = entry.stringKeyOrNull();
+			if (key != NULL) {
+				zend_hash_del(result.table(), key);
+			} else {
+				zend_hash_index_del(result.table(), entry.indexKey());
+			}
+		}
+		return result;
+	}
+
+	/* private static (twin findMergedCallCandidates()): certain merged call
+	 * expressions whose type differs between the merged branches */
+	static zv::Val findMergedCallCandidates(HashTable *differingExpressionKeys, HashTable *mergedExpressionTypes)
+	{
+		static const int callClasses[] = { PT_CLASS_FUNC_CALL, PT_CLASS_METHOD_CALL, PT_CLASS_STATIC_CALL };
+		zv::Arr candidates = zv::Arr::create(0);
+		for (auto entry : zv::TableRef(differingExpressionKeys)) {
+			zend_string *key = entry.stringKeyOrNull();
+			zval *holder = key != NULL ? zend_hash_find(mergedExpressionTypes, key) : zend_hash_index_find(mergedExpressionTypes, entry.indexKey());
+			if (holder == NULL) continue;
+			zend_long certainty = holderCertainty(zv::Ref(holder));
+			if (UNEXPECTED(certainty < 0)) return zv::Val();
+			if (certainty != PT_TRI_YES) continue;
+			zv::Val expr = holderExpr(zv::Ref(holder));
+			if (UNEXPECTED(expr.isUndef())) return zv::Val();
+			bool isCall = false;
+			for (int classIdx : callClasses) {
+				if (UNEXPECTED(!isInstance(expr.ref(), classIdx, isCall))) return zv::Val();
+				if (isCall) break;
+			}
+			if (!isCall) continue;
+			candidates.separate();
+			Z_TRY_ADDREF_P(holder);
+			if (key != NULL) {
+				zend_hash_add_new(candidates.table(), key, holder);
+			} else {
+				zend_hash_index_add_new(candidates.table(), entry.indexKey(), holder);
+			}
+		}
+		return zv::Val(std::move(candidates));
+	}
+
+	/* private (twin findUninformativeMergedCalls(), called on the merged scope
+	 * without the candidates): keys of candidates whose merged type (and
+	 * native type) is exactly what the call resolves to there */
+	static zv::Val findUninformativeMergedCalls(zv::Val &scope, HashTable *candidates, HashTable *mergedNativeTypes)
+	{
+		zend_object *scopeObject = requireObject(scope, "getType");
+		if (UNEXPECTED(scopeObject == NULL)) return zv::Val();
+
+		zv::Arr uninformativeKeys = zv::Arr::create(0);
+		for (auto entry : zv::TableRef(candidates)) {
+			zv::Val expr = holderExpr(entry.value());
+			if (UNEXPECTED(expr.isUndef())) return zv::Val();
+			zv::Val type = holderType(entry.value());
+			if (UNEXPECTED(type.isUndef())) return zv::Val();
+			zv::Val freshType = pt_mutating_scope_get_type(scopeObject, expr.raw());
+			if (UNEXPECTED(freshType.isUndef())) return zv::Val();
+			bool equal = pt_call_type_equals(type.raw(), freshType.raw());
+			if (UNEXPECTED(EG(exception) != NULL)) return zv::Val();
+			if (!equal) continue;
+			zend_string *key = entry.stringKeyOrNull();
+			zval *nativeHolder = key != NULL ? zend_hash_find(mergedNativeTypes, key) : zend_hash_index_find(mergedNativeTypes, entry.indexKey());
+			if (nativeHolder != NULL) {
+				zv::Val nativeType = holderType(zv::Ref(nativeHolder));
+				if (UNEXPECTED(nativeType.isUndef())) return zv::Val();
+				zv::Val freshNativeType = pt_mutating_scope_get_native_type(scopeObject, expr.raw());
+				if (UNEXPECTED(freshNativeType.isUndef())) return zv::Val();
+				bool nativeEqual = pt_call_type_equals(nativeType.raw(), freshNativeType.raw());
+				if (UNEXPECTED(EG(exception) != NULL)) return zv::Val();
+				if (!nativeEqual) continue;
+			}
+			uninformativeKeys.separate();
+			zval trueZv;
+			ZVAL_TRUE(&trueZv);
+			if (key != NULL) {
+				zend_hash_add_new(uninformativeKeys.table(), key, &trueZv);
+			} else {
+				zend_hash_index_add_new(uninformativeKeys.table(), entry.indexKey(), &trueZv);
+			}
+		}
+		return zv::Val(std::move(uninformativeKeys));
 	}
 
 	/* private (twin 4476) — drops the keys of class-constant fetches that
diff --git a/turbo-ext/src/generated/MutatingScope.h b/turbo-ext/src/generated/MutatingScope.h
index e01ebcdf60c..185b41a21e1 100644
--- a/turbo-ext/src/generated/MutatingScope.h
+++ b/turbo-ext/src/generated/MutatingScope.h
@@ -393,106 +393,111 @@ inline constexpr char strings[] =
 	"collectAbsorbedClosures\0" /* 6540 */
 	"mergeWithVariableState\0" /* 6564 */
 	"differingExpressionKeys\0" /* 6587 */
-	"ourExpressionTypes\0" /* 6611 */
-	"theirExpressionTypes\0" /* 6630 */
-	"withoutPreciseClassConstantFetches\0" /* 6651 */
-	"currentConditionalExpressions\0" /* 6686 */
-	"sourceConditionalExpressions\0" /* 6716 */
-	"otherExpressionTypes\0" /* 6745 */
-	"preserveVacuousConditionalExpressions\0" /* 6766 */
-	"ourConditionalExpressions\0" /* 6804 */
-	"theirConditionalExpressions\0" /* 6830 */
-	"mergeSameGuardConditionalExpressions\0" /* 6858 */
-	"newConditionalExpressions\0" /* 6895 */
-	"existingConditionalExpressions\0" /* 6921 */
-	"mergeConditionalExpressions\0" /* 6952 */
-	"calledMethodScope\0" /* 6980 */
-	"mergeInitializedProperties\0" /* 6998 */
-	"finallyScope\0" /* 7025 */
-	"originalFinallyScope\0" /* 7038 */
-	"processFinallyScope\0" /* 7059 */
-	"ourVariableTypeHolders\0" /* 7079 */
-	"finallyVariableTypeHolders\0" /* 7102 */
-	"originalVariableTypeHolders\0" /* 7129 */
-	"processFinallyScopeVariableTypeHolders\0" /* 7157 */
-	"closureScope\0" /* 7196 */
-	"prevScope\0" /* 7209 */
-	"byRefUses\0" /* 7219 */
-	"processClosureScope\0" /* 7229 */
-	"finalScope\0" /* 7249 */
-	"processAlwaysIterableForeachScopeWithoutPollute\0" /* 7260 */
-	"writableVariableNames\0" /* 7308 */
-	"generalizeWith\0" /* 7330 */
-	"generalizeWithVariableState\0" /* 7345 */
-	"variableTypeHolders\0" /* 7373 */
-	"otherVariableTypeHolders\0" /* 7393 */
-	"generalizeVariableTypeHolders\0" /* 7418 */
-	"flattenUnionForGeneralization\0" /* 7448 */
-	"a\0" /* 7478 */
-	"b\0" /* 7480 */
-	"depth\0" /* 7482 */
-	"generalizeType\0" /* 7488 */
-	"getArrayDepth\0" /* 7503 */
-	"equals\0" /* 7517 */
-	"otherConditionalExpressions\0" /* 7524 */
-	"compareConditionalExpressions\0" /* 7552 */
-	"compareVariableTypeHolders\0" /* 7582 */
-	"propertyReflection\0" /* 7609 */
-	"PHPStan\\Reflection\\PropertyReflection\0" /* 7628 */
-	"canAccessProperty\0" /* 7666 */
-	"PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7684 */
-	"canReadProperty\0" /* 7730 */
-	"canWriteProperty\0" /* 7746 */
-	"methodReflection\0" /* 7763 */
-	"PHPStan\\Reflection\\MethodReflection\0" /* 7780 */
-	"canCallMethod\0" /* 7816 */
-	"constantReflection\0" /* 7830 */
-	"PHPStan\\Reflection\\ClassConstantReflection\0" /* 7849 */
-	"canAccessConstant\0" /* 7892 */
-	"classMemberReflection\0" /* 7910 */
-	"PHPStan\\Reflection\\ClassMemberReflection\0" /* 7932 */
-	"canAccessClassMember\0" /* 7973 */
-	"debug\0" /* 7994 */
-	"typeWithMethod\0" /* 8000 */
-	"methodName\0" /* 8015 */
-	"filterTypeWithMethod\0" /* 8026 */
-	"PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8047 */
-	"getMethodReflection\0" /* 8091 */
-	"getNakedMethod\0" /* 8111 */
-	"typeWithProperty\0" /* 8126 */
-	"getPropertyReflection\0" /* 8143 */
-	"getInstancePropertyReflection\0" /* 8165 */
-	"getStaticPropertyReflection\0" /* 8195 */
-	"typeWithConstant\0" /* 8223 */
-	"constantName\0" /* 8240 */
-	"getConstantReflection\0" /* 8253 */
-	"constantType\0" /* 8275 */
-	"getConstantExplicitTypeFromConfig\0" /* 8288 */
-	"getConstantTypes\0" /* 8322 */
-	"getGlobalConstantType\0" /* 8339 */
-	"nameString\0" /* 8361 */
-	"createGlobalConstantFetches\0" /* 8372 */
-	"getNativeConstantTypes\0" /* 8400 */
-	"getIterableKeyType\0" /* 8423 */
-	"getIterableValueType\0" /* 8442 */
-	"PHPStan\\Php\\PhpVersions\0" /* 8463 */
-	"getPhpVersion\0" /* 8487 */
-	"getConfiguredPhpVersionRange\0" /* 8501 */
-	"isOverallPhpVersionRange\0" /* 8530 */
-	"PhpParser\\Node\0" /* 8555 */
-	"invokeNodeCallback\0" /* 8570 */
-	"collectorType\0" /* 8589 */
-	"data\0" /* 8603 */
-	"emitCollectedData\0" /* 8608 */
-	"extensionClass\0" /* 8626 */
-	"trackValueDependency\0" /* 8641 */
-	"file\0" /* 8662 */
-	"trackFileDependency\0" /* 8667 */
-	"directory\0" /* 8687 */
-	"pattern\0" /* 8697 */
-	"'*'\0" /* 8705 */
-	"trackDirectoryDependency\0" /* 8709 */
-	"trackClassDependency"; /* 8734 */
+	"mergedExpressionTypes\0" /* 6611 */
+	"findMergedCallCandidates\0" /* 6633 */
+	"candidates\0" /* 6658 */
+	"mergedNativeTypes\0" /* 6669 */
+	"findUninformativeMergedCalls\0" /* 6687 */
+	"ourExpressionTypes\0" /* 6716 */
+	"theirExpressionTypes\0" /* 6735 */
+	"withoutPreciseClassConstantFetches\0" /* 6756 */
+	"currentConditionalExpressions\0" /* 6791 */
+	"sourceConditionalExpressions\0" /* 6821 */
+	"otherExpressionTypes\0" /* 6850 */
+	"preserveVacuousConditionalExpressions\0" /* 6871 */
+	"ourConditionalExpressions\0" /* 6909 */
+	"theirConditionalExpressions\0" /* 6935 */
+	"mergeSameGuardConditionalExpressions\0" /* 6963 */
+	"newConditionalExpressions\0" /* 7000 */
+	"existingConditionalExpressions\0" /* 7026 */
+	"mergeConditionalExpressions\0" /* 7057 */
+	"calledMethodScope\0" /* 7085 */
+	"mergeInitializedProperties\0" /* 7103 */
+	"finallyScope\0" /* 7130 */
+	"originalFinallyScope\0" /* 7143 */
+	"processFinallyScope\0" /* 7164 */
+	"ourVariableTypeHolders\0" /* 7184 */
+	"finallyVariableTypeHolders\0" /* 7207 */
+	"originalVariableTypeHolders\0" /* 7234 */
+	"processFinallyScopeVariableTypeHolders\0" /* 7262 */
+	"closureScope\0" /* 7301 */
+	"prevScope\0" /* 7314 */
+	"byRefUses\0" /* 7324 */
+	"processClosureScope\0" /* 7334 */
+	"finalScope\0" /* 7354 */
+	"processAlwaysIterableForeachScopeWithoutPollute\0" /* 7365 */
+	"writableVariableNames\0" /* 7413 */
+	"generalizeWith\0" /* 7435 */
+	"generalizeWithVariableState\0" /* 7450 */
+	"variableTypeHolders\0" /* 7478 */
+	"otherVariableTypeHolders\0" /* 7498 */
+	"generalizeVariableTypeHolders\0" /* 7523 */
+	"flattenUnionForGeneralization\0" /* 7553 */
+	"a\0" /* 7583 */
+	"b\0" /* 7585 */
+	"depth\0" /* 7587 */
+	"generalizeType\0" /* 7593 */
+	"getArrayDepth\0" /* 7608 */
+	"equals\0" /* 7622 */
+	"otherConditionalExpressions\0" /* 7629 */
+	"compareConditionalExpressions\0" /* 7657 */
+	"compareVariableTypeHolders\0" /* 7687 */
+	"propertyReflection\0" /* 7714 */
+	"PHPStan\\Reflection\\PropertyReflection\0" /* 7733 */
+	"canAccessProperty\0" /* 7771 */
+	"PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7789 */
+	"canReadProperty\0" /* 7835 */
+	"canWriteProperty\0" /* 7851 */
+	"methodReflection\0" /* 7868 */
+	"PHPStan\\Reflection\\MethodReflection\0" /* 7885 */
+	"canCallMethod\0" /* 7921 */
+	"constantReflection\0" /* 7935 */
+	"PHPStan\\Reflection\\ClassConstantReflection\0" /* 7954 */
+	"canAccessConstant\0" /* 7997 */
+	"classMemberReflection\0" /* 8015 */
+	"PHPStan\\Reflection\\ClassMemberReflection\0" /* 8037 */
+	"canAccessClassMember\0" /* 8078 */
+	"debug\0" /* 8099 */
+	"typeWithMethod\0" /* 8105 */
+	"methodName\0" /* 8120 */
+	"filterTypeWithMethod\0" /* 8131 */
+	"PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8152 */
+	"getMethodReflection\0" /* 8196 */
+	"getNakedMethod\0" /* 8216 */
+	"typeWithProperty\0" /* 8231 */
+	"getPropertyReflection\0" /* 8248 */
+	"getInstancePropertyReflection\0" /* 8270 */
+	"getStaticPropertyReflection\0" /* 8300 */
+	"typeWithConstant\0" /* 8328 */
+	"constantName\0" /* 8345 */
+	"getConstantReflection\0" /* 8358 */
+	"constantType\0" /* 8380 */
+	"getConstantExplicitTypeFromConfig\0" /* 8393 */
+	"getConstantTypes\0" /* 8427 */
+	"getGlobalConstantType\0" /* 8444 */
+	"nameString\0" /* 8466 */
+	"createGlobalConstantFetches\0" /* 8477 */
+	"getNativeConstantTypes\0" /* 8505 */
+	"getIterableKeyType\0" /* 8528 */
+	"getIterableValueType\0" /* 8547 */
+	"PHPStan\\Php\\PhpVersions\0" /* 8568 */
+	"getPhpVersion\0" /* 8592 */
+	"getConfiguredPhpVersionRange\0" /* 8606 */
+	"isOverallPhpVersionRange\0" /* 8635 */
+	"PhpParser\\Node\0" /* 8660 */
+	"invokeNodeCallback\0" /* 8675 */
+	"collectorType\0" /* 8694 */
+	"data\0" /* 8708 */
+	"emitCollectedData\0" /* 8713 */
+	"extensionClass\0" /* 8731 */
+	"trackValueDependency\0" /* 8746 */
+	"file\0" /* 8767 */
+	"trackFileDependency\0" /* 8772 */
+	"directory\0" /* 8792 */
+	"pattern\0" /* 8802 */
+	"'*'\0" /* 8810 */
+	"trackDirectoryDependency\0" /* 8814 */
+	"trackClassDependency"; /* 8839 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 9), /* __construct $services */
 	reg::packed(40, 0, 53), /* __construct $scopeFactory */
@@ -899,104 +904,110 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(6479, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */
 	reg::packed(6490, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWithVariableState $preserveVacuousConditionals */
 	reg::packed(738, 0, 523), /* mergeWithVariableState return */
+	reg::packed(6587, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */
+	reg::packed(6611, MAY_BE_ARRAY), /* findMergedCallCandidates $mergedExpressionTypes */
+	reg::packed(738, MAY_BE_ARRAY), /* findMergedCallCandidates return */
+	reg::packed(6658, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */
+	reg::packed(6669, MAY_BE_ARRAY), /* findUninformativeMergedCalls $mergedNativeTypes */
+	reg::packed(738, MAY_BE_ARRAY), /* findUninformativeMergedCalls return */
 	reg::packed(6587, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */
-	reg::packed(6611, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */
-	reg::packed(6630, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */
+	reg::packed(6716, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */
+	reg::packed(6735, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */
 	reg::packed(738, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches return */
-	reg::packed(6686, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */
-	reg::packed(6716, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */
-	reg::packed(6745, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */
+	reg::packed(6791, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */
+	reg::packed(6821, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */
+	reg::packed(6850, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */
 	reg::packed(738, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions return */
-	reg::packed(6686, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */
-	reg::packed(6804, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */
-	reg::packed(6830, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */
+	reg::packed(6791, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */
+	reg::packed(6909, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */
+	reg::packed(6935, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */
 	reg::packed(738, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions return */
-	reg::packed(6895, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */
-	reg::packed(6921, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */
+	reg::packed(7000, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */
+	reg::packed(7026, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */
 	reg::packed(738, MAY_BE_ARRAY), /* mergeConditionalExpressions return */
-	reg::packed(6980, 0, 523), /* mergeInitializedProperties $calledMethodScope */
+	reg::packed(7085, 0, 523), /* mergeInitializedProperties $calledMethodScope */
 	reg::packed(738, 0, 523), /* mergeInitializedProperties return */
-	reg::packed(7025, 0, 523), /* processFinallyScope $finallyScope */
-	reg::packed(7038, 0, 523), /* processFinallyScope $originalFinallyScope */
+	reg::packed(7130, 0, 523), /* processFinallyScope $finallyScope */
+	reg::packed(7143, 0, 523), /* processFinallyScope $originalFinallyScope */
 	reg::packed(738, 0, 523), /* processFinallyScope return */
-	reg::packed(7079, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */
-	reg::packed(7102, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */
-	reg::packed(7129, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */
+	reg::packed(7184, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */
+	reg::packed(7207, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */
+	reg::packed(7234, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */
 	reg::packed(738, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders return */
-	reg::packed(7196, 0, 523), /* processClosureScope $closureScope */
-	reg::packed(7209, MAY_BE_NULL, 523), /* processClosureScope $prevScope */
-	reg::packed(7219, MAY_BE_ARRAY), /* processClosureScope $byRefUses */
+	reg::packed(7301, 0, 523), /* processClosureScope $closureScope */
+	reg::packed(7314, MAY_BE_NULL, 523), /* processClosureScope $prevScope */
+	reg::packed(7324, MAY_BE_ARRAY), /* processClosureScope $byRefUses */
 	reg::packed(738, 0, 523), /* processClosureScope return */
-	reg::packed(7249, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */
+	reg::packed(7354, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */
 	reg::packed(738, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute return */
 	reg::packed(6479, 0, 523), /* generalizeWith $otherScope */
-	reg::packed(7308, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */
+	reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */
 	reg::packed(738, 0, 523), /* generalizeWith return */
 	reg::packed(6479, 0, 523), /* generalizeWithVariableState $otherScope */
-	reg::packed(7308, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */
+	reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */
 	reg::packed(738, 0, 523), /* generalizeWithVariableState return */
-	reg::packed(7373, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */
-	reg::packed(7393, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */
-	reg::packed(7308, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */
+	reg::packed(7478, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */
+	reg::packed(7498, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */
+	reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */
 	reg::packed(738, MAY_BE_ARRAY), /* generalizeVariableTypeHolders return */
 	reg::packed(3874, 0, 1424), /* flattenUnionForGeneralization $type */
 	reg::packed(738, MAY_BE_ARRAY), /* flattenUnionForGeneralization return */
-	reg::packed(7478, 0, 1424), /* generalizeType $a */
-	reg::packed(7480, 0, 1424), /* generalizeType $b */
-	reg::packed(7482, MAY_BE_LONG), /* generalizeType $depth */
+	reg::packed(7583, 0, 1424), /* generalizeType $a */
+	reg::packed(7585, 0, 1424), /* generalizeType $b */
+	reg::packed(7587, MAY_BE_LONG), /* generalizeType $depth */
 	reg::packed(738, 0, 1424), /* generalizeType return */
 	reg::packed(3874, 0, 1424), /* getArrayDepth $type */
 	reg::packed(738, MAY_BE_LONG), /* getArrayDepth return */
 	reg::packed(6479, 0, 523), /* equals $otherScope */
 	reg::packed(738, MAY_BE_BOOL), /* equals return */
 	reg::packed(278, MAY_BE_ARRAY), /* compareConditionalExpressions $conditionalExpressions */
-	reg::packed(7524, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */
+	reg::packed(7629, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */
 	reg::packed(738, MAY_BE_BOOL), /* compareConditionalExpressions return */
-	reg::packed(7373, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */
-	reg::packed(7393, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */
+	reg::packed(7478, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */
+	reg::packed(7498, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */
 	reg::packed(738, MAY_BE_BOOL), /* compareVariableTypeHolders return */
-	reg::packed(7609, 0, 7628), /* canAccessProperty $propertyReflection */
+	reg::packed(7714, 0, 7733), /* canAccessProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canAccessProperty return */
-	reg::packed(7609, 0, 7684), /* canReadProperty $propertyReflection */
+	reg::packed(7714, 0, 7789), /* canReadProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canReadProperty return */
-	reg::packed(7609, 0, 7684), /* canWriteProperty $propertyReflection */
+	reg::packed(7714, 0, 7789), /* canWriteProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canWriteProperty return */
-	reg::packed(7763, 0, 7780), /* canCallMethod $methodReflection */
+	reg::packed(7868, 0, 7885), /* canCallMethod $methodReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canCallMethod return */
-	reg::packed(7830, 0, 7849), /* canAccessConstant $constantReflection */
+	reg::packed(7935, 0, 7954), /* canAccessConstant $constantReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canAccessConstant return */
-	reg::packed(7910, 0, 7932), /* canAccessClassMember $classMemberReflection */
+	reg::packed(8015, 0, 8037), /* canAccessClassMember $classMemberReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canAccessClassMember return */
 	reg::packed(738, MAY_BE_ARRAY), /* debug return */
-	reg::packed(8000, 0, 1424), /* filterTypeWithMethod $typeWithMethod */
-	reg::packed(8015, MAY_BE_STRING), /* filterTypeWithMethod $methodName */
+	reg::packed(8105, 0, 1424), /* filterTypeWithMethod $typeWithMethod */
+	reg::packed(8120, MAY_BE_STRING), /* filterTypeWithMethod $methodName */
 	reg::packed(738, MAY_BE_NULL, 1424), /* filterTypeWithMethod return */
-	reg::packed(8000, 0, 1424), /* getMethodReflection $typeWithMethod */
-	reg::packed(8015, MAY_BE_STRING), /* getMethodReflection $methodName */
-	reg::packed(738, MAY_BE_NULL, 8047), /* getMethodReflection return */
-	reg::packed(8000, 0, 1424), /* getNakedMethod $typeWithMethod */
-	reg::packed(8015, MAY_BE_STRING), /* getNakedMethod $methodName */
-	reg::packed(738, MAY_BE_NULL, 8047), /* getNakedMethod return */
-	reg::packed(8126, 0, 1424), /* getPropertyReflection $typeWithProperty */
+	reg::packed(8105, 0, 1424), /* getMethodReflection $typeWithMethod */
+	reg::packed(8120, MAY_BE_STRING), /* getMethodReflection $methodName */
+	reg::packed(738, MAY_BE_NULL, 8152), /* getMethodReflection return */
+	reg::packed(8105, 0, 1424), /* getNakedMethod $typeWithMethod */
+	reg::packed(8120, MAY_BE_STRING), /* getNakedMethod $methodName */
+	reg::packed(738, MAY_BE_NULL, 8152), /* getNakedMethod return */
+	reg::packed(8231, 0, 1424), /* getPropertyReflection $typeWithProperty */
 	reg::packed(3728, MAY_BE_STRING), /* getPropertyReflection $propertyName */
-	reg::packed(738, MAY_BE_NULL, 7684), /* getPropertyReflection return */
-	reg::packed(8126, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */
+	reg::packed(738, MAY_BE_NULL, 7789), /* getPropertyReflection return */
+	reg::packed(8231, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */
 	reg::packed(3728, MAY_BE_STRING), /* getInstancePropertyReflection $propertyName */
-	reg::packed(738, MAY_BE_NULL, 7684), /* getInstancePropertyReflection return */
-	reg::packed(8126, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */
+	reg::packed(738, MAY_BE_NULL, 7789), /* getInstancePropertyReflection return */
+	reg::packed(8231, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */
 	reg::packed(3728, MAY_BE_STRING), /* getStaticPropertyReflection $propertyName */
-	reg::packed(738, MAY_BE_NULL, 7684), /* getStaticPropertyReflection return */
-	reg::packed(8223, 0, 1424), /* getConstantReflection $typeWithConstant */
-	reg::packed(8240, MAY_BE_STRING), /* getConstantReflection $constantName */
-	reg::packed(738, MAY_BE_NULL, 7849), /* getConstantReflection return */
-	reg::packed(8240, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */
-	reg::packed(8275, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */
+	reg::packed(738, MAY_BE_NULL, 7789), /* getStaticPropertyReflection return */
+	reg::packed(8328, 0, 1424), /* getConstantReflection $typeWithConstant */
+	reg::packed(8345, MAY_BE_STRING), /* getConstantReflection $constantName */
+	reg::packed(738, MAY_BE_NULL, 7954), /* getConstantReflection return */
+	reg::packed(8345, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */
+	reg::packed(8380, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */
 	reg::packed(738, 0, 1424), /* getConstantExplicitTypeFromConfig return */
 	reg::packed(738, MAY_BE_ARRAY), /* getConstantTypes return */
 	reg::packed(1520, 0, 1525), /* getGlobalConstantType $name */
 	reg::packed(738, MAY_BE_NULL, 1424), /* getGlobalConstantType return */
 	reg::packed(1520, 0, 1525), /* createGlobalConstantFetches $name */
-	reg::packed(8361, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */
+	reg::packed(8466, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */
 	reg::packed(227, MAY_BE_NULL | MAY_BE_STRING), /* createGlobalConstantFetches $namespace */
 	reg::packed(738, MAY_BE_ARRAY), /* createGlobalConstantFetches return */
 	reg::packed(738, MAY_BE_ARRAY), /* getNativeConstantTypes return */
@@ -1004,22 +1015,22 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(738, 0, 1424), /* getIterableKeyType return */
 	reg::packed(5138, 0, 1424), /* getIterableValueType $iteratee */
 	reg::packed(738, 0, 1424), /* getIterableValueType return */
-	reg::packed(738, 0, 8463), /* getPhpVersion return */
+	reg::packed(738, 0, 8568), /* getPhpVersion return */
 	reg::packed(738, MAY_BE_NULL, 1424), /* getConfiguredPhpVersionRange return */
 	reg::packed(3874, 0, 1424), /* isOverallPhpVersionRange $type */
 	reg::packed(738, MAY_BE_BOOL), /* isOverallPhpVersionRange return */
-	reg::packed(1707, 0, 8555), /* invokeNodeCallback $node */
+	reg::packed(1707, 0, 8660), /* invokeNodeCallback $node */
 	reg::packed(738, MAY_BE_VOID), /* invokeNodeCallback return */
-	reg::packed(8589, MAY_BE_STRING), /* emitCollectedData $collectorType */
-	reg::packed(8603, MAY_BE_ANY), /* emitCollectedData $data */
+	reg::packed(8694, MAY_BE_STRING), /* emitCollectedData $collectorType */
+	reg::packed(8708, MAY_BE_ANY), /* emitCollectedData $data */
 	reg::packed(738, MAY_BE_VOID), /* emitCollectedData return */
-	reg::packed(8626, MAY_BE_STRING), /* trackValueDependency $extensionClass */
+	reg::packed(8731, MAY_BE_STRING), /* trackValueDependency $extensionClass */
 	reg::packed(2540, MAY_BE_STRING), /* trackValueDependency $key */
 	reg::packed(738, MAY_BE_VOID), /* trackValueDependency return */
-	reg::packed(8662, MAY_BE_STRING), /* trackFileDependency $file */
+	reg::packed(8767, MAY_BE_STRING), /* trackFileDependency $file */
 	reg::packed(738, MAY_BE_VOID), /* trackFileDependency return */
-	reg::packed(8687, MAY_BE_STRING), /* trackDirectoryDependency $directory */
-	reg::packed(8697, MAY_BE_STRING, reg::NoString, false, false, 8705), /* trackDirectoryDependency $pattern */
+	reg::packed(8792, MAY_BE_STRING), /* trackDirectoryDependency $directory */
+	reg::packed(8802, MAY_BE_STRING, reg::NoString, false, false, 8810), /* trackDirectoryDependency $pattern */
 	reg::packed(738, MAY_BE_VOID), /* trackDirectoryDependency return */
 	reg::packed(2977, MAY_BE_STRING), /* trackClassDependency $className */
 	reg::packed(738, MAY_BE_VOID), /* trackClassDependency return */
@@ -1180,54 +1191,56 @@ inline constexpr sigtab::Sig isInFirstLevelStatement = { { 6455 /* isInFirstLeve
 inline constexpr sigtab::Sig mergeWith = { { 6518 /* mergeWith */, 1, 396, 2, 398, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig collectAbsorbedClosures = { { 6540 /* collectAbsorbedClosures */, 2, 399, 2, 401, ZEND_ACC_PRIVATE } };
 inline constexpr sigtab::Sig mergeWithVariableState = { { 6564 /* mergeWithVariableState */, 1, 402, 2, 404, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6651 /* withoutPreciseClassConstantFetches */, 3, 405, 3, 408, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 6766 /* preserveVacuousConditionalExpressions */, 3, 409, 3, 412, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 6858 /* mergeSameGuardConditionalExpressions */, 3, 413, 3, 416, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig mergeConditionalExpressions = { { 6952 /* mergeConditionalExpressions */, 2, 417, 2, 419, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig mergeInitializedProperties = { { 6998 /* mergeInitializedProperties */, 1, 420, 1, 421, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processFinallyScope = { { 7059 /* processFinallyScope */, 2, 422, 2, 424, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7157 /* processFinallyScopeVariableTypeHolders */, 3, 425, 3, 428, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig processClosureScope = { { 7229 /* processClosureScope */, 3, 429, 3, 432, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7260 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 433, 1, 434, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig generalizeWith = { { 7330 /* generalizeWith */, 1, 435, 2, 437, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig generalizeWithVariableState = { { 7345 /* generalizeWithVariableState */, 2, 438, 2, 440, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7418 /* generalizeVariableTypeHolders */, 3, 441, 3, 444, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7448 /* flattenUnionForGeneralization */, 1, 445, 1, 446, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig generalizeType = { { 7488 /* generalizeType */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getArrayDepth = { { 7503 /* getArrayDepth */, 1, 451, 1, 452, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig equals = { { 7517 /* equals */, 1, 453, 1, 454, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig compareConditionalExpressions = { { 7552 /* compareConditionalExpressions */, 2, 455, 2, 457, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7582 /* compareVariableTypeHolders */, 2, 458, 2, 460, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig canAccessProperty = { { 7666 /* canAccessProperty */, 1, 461, 1, 462, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canReadProperty = { { 7730 /* canReadProperty */, 1, 463, 1, 464, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canWriteProperty = { { 7746 /* canWriteProperty */, 1, 465, 1, 466, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canCallMethod = { { 7816 /* canCallMethod */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canAccessConstant = { { 7892 /* canAccessConstant */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canAccessClassMember = { { 7973 /* canAccessClassMember */, 1, 471, 1, 472, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig debug = { { 7994 /* debug */, 0, 473, 0, 473, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig filterTypeWithMethod = { { 8026 /* filterTypeWithMethod */, 2, 474, 2, 476, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getMethodReflection = { { 8091 /* getMethodReflection */, 2, 477, 2, 479, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getNakedMethod = { { 8111 /* getNakedMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getPropertyReflection = { { 8143 /* getPropertyReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8165 /* getInstancePropertyReflection */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8195 /* getStaticPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConstantReflection = { { 8253 /* getConstantReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8288 /* getConstantExplicitTypeFromConfig */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConstantTypes = { { 8322 /* getConstantTypes */, 0, 498, 0, 498, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getGlobalConstantType = { { 8339 /* getGlobalConstantType */, 1, 499, 1, 500, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8372 /* createGlobalConstantFetches */, 3, 501, 3, 504, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getNativeConstantTypes = { { 8400 /* getNativeConstantTypes */, 0, 505, 0, 505, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getIterableKeyType = { { 8423 /* getIterableKeyType */, 1, 506, 1, 507, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getIterableValueType = { { 8442 /* getIterableValueType */, 1, 508, 1, 509, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getPhpVersion = { { 8487 /* getPhpVersion */, 0, 510, 0, 510, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8501 /* getConfiguredPhpVersionRange */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8530 /* isOverallPhpVersionRange */, 1, 512, 1, 513, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig invokeNodeCallback = { { 8570 /* invokeNodeCallback */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig emitCollectedData = { { 8608 /* emitCollectedData */, 2, 516, 2, 518, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig trackValueDependency = { { 8641 /* trackValueDependency */, 2, 519, 2, 521, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig trackFileDependency = { { 8667 /* trackFileDependency */, 1, 522, 1, 523, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig trackDirectoryDependency = { { 8709 /* trackDirectoryDependency */, 1, 524, 2, 526, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig trackClassDependency = { { 8734 /* trackClassDependency */, 1, 527, 1, 528, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig findMergedCallCandidates = { { 6633 /* findMergedCallCandidates */, 2, 405, 2, 407, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig findUninformativeMergedCalls = { { 6687 /* findUninformativeMergedCalls */, 2, 408, 2, 410, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6756 /* withoutPreciseClassConstantFetches */, 3, 411, 3, 414, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 6871 /* preserveVacuousConditionalExpressions */, 3, 415, 3, 418, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 6963 /* mergeSameGuardConditionalExpressions */, 3, 419, 3, 422, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig mergeConditionalExpressions = { { 7057 /* mergeConditionalExpressions */, 2, 423, 2, 425, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig mergeInitializedProperties = { { 7103 /* mergeInitializedProperties */, 1, 426, 1, 427, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig processFinallyScope = { { 7164 /* processFinallyScope */, 2, 428, 2, 430, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7262 /* processFinallyScopeVariableTypeHolders */, 3, 431, 3, 434, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig processClosureScope = { { 7334 /* processClosureScope */, 3, 435, 3, 438, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7365 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 439, 1, 440, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig generalizeWith = { { 7435 /* generalizeWith */, 1, 441, 2, 443, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig generalizeWithVariableState = { { 7450 /* generalizeWithVariableState */, 2, 444, 2, 446, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7523 /* generalizeVariableTypeHolders */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7553 /* flattenUnionForGeneralization */, 1, 451, 1, 452, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig generalizeType = { { 7593 /* generalizeType */, 3, 453, 3, 456, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getArrayDepth = { { 7608 /* getArrayDepth */, 1, 457, 1, 458, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig equals = { { 7622 /* equals */, 1, 459, 1, 460, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig compareConditionalExpressions = { { 7657 /* compareConditionalExpressions */, 2, 461, 2, 463, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7687 /* compareVariableTypeHolders */, 2, 464, 2, 466, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig canAccessProperty = { { 7771 /* canAccessProperty */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canReadProperty = { { 7835 /* canReadProperty */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canWriteProperty = { { 7851 /* canWriteProperty */, 1, 471, 1, 472, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canCallMethod = { { 7921 /* canCallMethod */, 1, 473, 1, 474, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canAccessConstant = { { 7997 /* canAccessConstant */, 1, 475, 1, 476, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canAccessClassMember = { { 8078 /* canAccessClassMember */, 1, 477, 1, 478, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig debug = { { 8099 /* debug */, 0, 479, 0, 479, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig filterTypeWithMethod = { { 8131 /* filterTypeWithMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getMethodReflection = { { 8196 /* getMethodReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getNakedMethod = { { 8216 /* getNakedMethod */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getPropertyReflection = { { 8248 /* getPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8270 /* getInstancePropertyReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8300 /* getStaticPropertyReflection */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConstantReflection = { { 8358 /* getConstantReflection */, 2, 498, 2, 500, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8393 /* getConstantExplicitTypeFromConfig */, 2, 501, 2, 503, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConstantTypes = { { 8427 /* getConstantTypes */, 0, 504, 0, 504, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getGlobalConstantType = { { 8444 /* getGlobalConstantType */, 1, 505, 1, 506, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8477 /* createGlobalConstantFetches */, 3, 507, 3, 510, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getNativeConstantTypes = { { 8505 /* getNativeConstantTypes */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getIterableKeyType = { { 8528 /* getIterableKeyType */, 1, 512, 1, 513, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getIterableValueType = { { 8547 /* getIterableValueType */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getPhpVersion = { { 8592 /* getPhpVersion */, 0, 516, 0, 516, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8606 /* getConfiguredPhpVersionRange */, 0, 517, 0, 517, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8635 /* isOverallPhpVersionRange */, 1, 518, 1, 519, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig invokeNodeCallback = { { 8675 /* invokeNodeCallback */, 1, 520, 1, 521, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig emitCollectedData = { { 8713 /* emitCollectedData */, 2, 522, 2, 524, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig trackValueDependency = { { 8746 /* trackValueDependency */, 2, 525, 2, 527, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig trackFileDependency = { { 8772 /* trackFileDependency */, 1, 528, 1, 529, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig trackDirectoryDependency = { { 8814 /* trackDirectoryDependency */, 1, 530, 2, 532, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig trackClassDependency = { { 8839 /* trackClassDependency */, 1, 533, 1, 534, ZEND_ACC_PUBLIC } };
 } // namespace sig
 
 } // namespace ptdecl::MutatingScope