From 28767a7afb7ca426712b588dbc3beacc12f645b8 Mon Sep 17 00:00:00 2001
From: Joe Savona <joesavona@fb.com>
Date: Thu, 12 Oct 2023 12:03:42 -0700
Subject: [PATCH] Inline reactive scope dep checks; no more change vars

Reactive scopes are currently preceded by individual variable declarations, one
for each of the scope's dependencies. Only after checking independently if each
of these dependencies has changed do we then do an "or" to check if we should
actually recompute the body of the scope.

But that's wasteful: it's more efficient to rely on `||` short-circuiting, and
recompute as soon as any input changes.

The main reason I can see not to do this is debugging. Having the change
variables makes it easy to see what changed. But at this point I think it makes
sense to optimize for code size and performance; we can always add back a
dev-only mode that uses change variables if that turns out to help debugging.
---
 .../ReactiveScopes/CodegenReactiveFunction.ts | 27 ++++++-------------
 .../compiler/alias-computed-load.expect.md    |  3 +--
 .../fixtures/compiler/alias-while.expect.md   |  3 +--
 ...ng-primitive-as-dep-nested-scope.expect.md | 11 +++-----
 .../allocating-primitive-as-dep.expect.md     |  3 +--
 .../allow-passing-refs-as-props.expect.md     |  3 +--
 .../array-access-assignment.expect.md         | 12 +++------
 .../compiler/array-at-closure.expect.md       | 10 +++----
 .../compiler/array-at-effect.expect.md        | 13 +++------
 .../array-expression-spread.expect.md         |  4 +--
 .../fixtures/compiler/array-join.expect.md    |  7 ++---
 ...ay-map-captures-receiver-noAlias.expect.md |  3 +--
 ...ay-map-noAlias-escaping-function.expect.md |  6 ++---
 .../compiler/array-pattern-params.expect.md   | 10 +++----
 .../compiler/array-properties.expect.md       |  9 ++-----
 .../compiler/array-property-call.expect.md    | 13 +++------
 .../compiler/array-push-effect.expect.md      | 10 +++----
 .../arrow-function-expr-gating-test.expect.md |  3 +--
 .../assignment-expression-computed.expect.md  |  3 +--
 ...ssignment-expression-nested-path.expect.md |  3 +--
 .../await-side-effecting-promise.expect.md    |  3 +--
 .../fixtures/compiler/await.expect.md         |  6 ++---
 .../babel-existing-react-import.expect.md     | 12 +++------
 ...xisting-react-kitchensink-import.expect.md | 12 +++------
 ...-existing-react-namespace-import.expect.md |  3 +--
 ...g.useMemo-deps-array-not-cleared.expect.md |  3 +--
 .../compiler/bug_object-pattern.expect.md     |  3 +--
 .../fixtures/compiler/call-spread.expect.md   |  4 +--
 ...ith-independently-memoizable-arg.expect.md |  6 ++---
 ...pture-indirect-mutate-alias-iife.expect.md |  3 +--
 .../capture-indirect-mutate-alias.expect.md   |  3 +--
 .../compiler/capture-param-mutate.expect.md   |  3 +--
 .../capture_mutate-across-fns-iife.expect.md  |  3 +--
 .../capture_mutate-across-fns.expect.md       |  3 +--
 .../capturing-arrow-function-1.expect.md      |  6 ++---
 ...fun-alias-captured-mutate-2-iife.expect.md |  4 +--
 ...ring-fun-alias-captured-mutate-2.expect.md |  4 +--
 ...alias-captured-mutate-arr-2-iife.expect.md |  4 +--
 ...-fun-alias-captured-mutate-arr-2.expect.md |  4 +--
 ...c-alias-captured-mutate-arr-iife.expect.md |  4 +--
 ...g-func-alias-captured-mutate-arr.expect.md |  4 +--
 ...-func-alias-captured-mutate-iife.expect.md |  4 +--
 ...uring-func-alias-captured-mutate.expect.md |  4 +--
 ...-func-alias-computed-mutate-iife.expect.md |  3 +--
 ...uring-func-alias-computed-mutate.expect.md |  3 +--
 ...capturing-func-alias-mutate-iife.expect.md |  3 +--
 .../capturing-func-alias-mutate.expect.md     |  3 +--
 ...as-receiver-computed-mutate-iife.expect.md |  3 +--
 ...c-alias-receiver-computed-mutate.expect.md |  3 +--
 ...-func-alias-receiver-mutate-iife.expect.md |  3 +--
 ...uring-func-alias-receiver-mutate.expect.md |  3 +--
 .../capturing-func-mutate-2.expect.md         |  7 ++---
 .../capturing-func-mutate-3.expect.md         |  3 +--
 .../capturing-func-mutate-nested.expect.md    |  3 +--
 .../compiler/capturing-func-mutate.expect.md  |  4 +--
 ...capturing-func-simple-alias-iife.expect.md |  3 +--
 .../capturing-func-simple-alias.expect.md     |  3 +--
 .../compiler/capturing-function-1.expect.md   |  6 ++---
 ...ction-alias-computed-load-2-iife.expect.md |  3 +--
 ...g-function-alias-computed-load-2.expect.md |  3 +--
 ...ction-alias-computed-load-3-iife.expect.md |  4 +--
 ...g-function-alias-computed-load-3.expect.md |  4 +--
 ...ction-alias-computed-load-4-iife.expect.md |  3 +--
 ...g-function-alias-computed-load-4.expect.md |  3 +--
 ...unction-alias-computed-load-iife.expect.md |  3 +--
 ...ing-function-alias-computed-load.expect.md |  3 +--
 ...nction-capture-ref-before-rename.expect.md | 10 +++----
 ...ction-conditional-capture-mutate.expect.md |  7 ++---
 .../capturing-function-decl.expect.md         |  3 +--
 ...g-function-member-expr-arguments.expect.md |  3 +--
 ...turing-function-member-expr-call.expect.md | 10 +++----
 .../capturing-function-renamed-ref.expect.md  |  3 +--
 ...apturing-function-runs-inference.expect.md |  9 +++----
 ...ring-function-skip-computed-path.expect.md |  3 +--
 .../capturing-function-within-block.expect.md |  6 ++---
 .../compiler/capturing-member-expr.expect.md  |  6 ++---
 .../capturing-nested-member-call.expect.md    |  3 +--
 ...ested-member-expr-in-nested-func.expect.md |  6 ++---
 .../capturing-nested-member-expr.expect.md    |  6 ++---
 ...capturing-reference-changes-type.expect.md |  3 +--
 ...pturing-variable-in-nested-block.expect.md |  6 ++---
 ...ring-variable-in-nested-function.expect.md |  6 ++---
 ...codegen-emit-imports-same-source.expect.md |  3 +--
 .../codegen-emit-make-read-only.expect.md     |  7 ++---
 ...en-instrument-forget-gating-test.expect.md |  6 ++---
 .../codegen-instrument-forget-test.expect.md  |  6 ++---
 ...component-declaration-basic.flow.expect.md |  3 +--
 .../fixtures/compiler/component.expect.md     | 11 +++-----
 .../compiler/computed-call-spread.expect.md   |  5 +---
 ...ted-load-primitive-as-dependency.expect.md |  3 +--
 .../compiler/computed-store-alias.expect.md   |  4 +--
 .../compiler/concise-arrow-expr.expect.md     |  3 +--
 ...ond-deps-conditional-member-expr.expect.md |  3 +--
 .../conditional-break-labeled.expect.md       | 11 ++++----
 .../compiler/conditional-break.expect.md      | 14 +++-------
 .../compiler/conditional-on-mutable.expect.md | 14 +++-------
 .../compiler/console-readonly.expect.md       |  3 +--
 .../compiler/constant-computed.expect.md      |  3 +--
 .../constant-propagate-global-phis.expect.md  |  3 +--
 .../compiler/controlled-input.expect.md       |  4 +--
 .../compiler/debugger-memoized.expect.md      |  3 +--
 .../default-param-array-with-unary.expect.md  |  3 +--
 ...ault-param-calls-global-function.expect.md |  3 +--
 ...efault-param-with-empty-callback.expect.md |  3 +--
 ...-param-with-reorderable-callback.expect.md |  3 +--
 .../delete-computed-property.expect.md        |  4 +--
 .../compiler/delete-property.expect.md        |  4 +--
 .../compiler/dependencies-outputs.expect.md   |  7 ++---
 .../fixtures/compiler/dependencies.expect.md  |  4 +--
 .../destructure-capture-global.expect.md      |  3 +--
 ...ructure-default-array-with-unary.expect.md |  3 +--
 .../destructuring-array-default.expect.md     |  3 +--
 ...cturing-assignment-array-default.expect.md |  3 +--
 .../destructuring-assignment.expect.md        |  6 +----
 ...and-local-variables-with-default.expect.md | 20 +++++---------
 ...ed-scope-declarations-and-locals.expect.md | 10 +++----
 .../destructuring-object-default.expect.md    |  3 +--
 ...uring-object-pattern-within-rest.expect.md |  7 ++---
 ...destructuring-property-inference.expect.md |  7 ++---
 ...h-typecast-as-default-value.flow.expect.md |  3 +--
 .../fixtures/compiler/destructuring.expect.md | 26 +++++++++---------
 .../compiler/do-while-compound-test.expect.md |  3 +--
 .../do-while-conditional-break.expect.md      |  3 +--
 .../drop-methodcall-usecallback.expect.md     |  6 ++---
 .../drop-methodcall-usememo.expect.md         |  3 +--
 ...alysis-destructured-rest-element.expect.md | 10 +++----
 .../escape-analysis-jsx-child.expect.md       | 12 +++------
 .../escape-analysis-logical.expect.md         | 14 +++-------
 ...nterleaved-allocating-dependency.expect.md |  7 ++---
 ...ved-allocating-nested-dependency.expect.md | 10 +++----
 ...interleaved-primitive-dependency.expect.md |  4 +--
 .../compiler/extend-scopes-if.expect.md       |  5 +---
 .../fbt-call-complex-param-value.expect.md    |  6 ++---
 .../fixtures/compiler/fbt-call.expect.md      |  6 ++---
 .../fbt-params-complex-param-value.expect.md  |  3 +--
 .../fixtures/compiler/fbt-params.expect.md    |  3 +--
 .../compiler/fbt-preserve-jsxtext.expect.md   |  3 +--
 .../fbt-template-string-same-scope.expect.md  |  6 ++---
 ...btparam-with-jsx-element-content.expect.md |  5 +---
 ...fbtparam-with-jsx-fragment-value.expect.md |  3 +--
 .../compiler/for-in-statement-break.expect.md |  3 +--
 .../for-in-statement-continue.expect.md       |  3 +--
 .../compiler/for-in-statement.expect.md       |  6 ++---
 .../function-declaration-simple.expect.md     |  3 +--
 ...-maybe-mutates-hook-return-value.expect.md |  6 ++---
 ...pression-with-store-to-parameter.expect.md |  3 +--
 ...unction-param-assignment-pattern.expect.md |  7 ++---
 ...ing-test-export-default-function.expect.md |  6 ++---
 ...test-export-function-and-default.expect.md |  6 ++---
 .../gating-test-export-function.expect.md     |  6 ++---
 .../fixtures/compiler/gating-test.expect.md   |  6 ++---
 ...sting-nested-const-declaration-2.expect.md |  3 +--
 .../compiler/holey-array-expr.expect.md       |  3 +--
 .../fixtures/compiler/hook-call.expect.md     |  3 +--
 .../fixtures/compiler/hook-noAlias.expect.md  |  7 ++---
 .../compiler/immutable-hooks.expect.md        |  3 +--
 ...rtent-mutability-readonly-lambda.expect.md |  3 +--
 .../compiler/independent-across-if.expect.md  |  9 ++-----
 .../fixtures/compiler/independent.expect.md   | 10 +++----
 ...endently-memoize-object-property.expect.md |  9 ++-----
 ...nctions-component-with-hook-call.expect.md |  3 +--
 ...er-functions-hook-with-hook-call.expect.md |  3 +--
 .../compiler/infer-global-object.expect.md    |  6 ++---
 ...-promoted-to-outer-scope-dynamic.expect.md | 15 +++--------
 .../interdependent-across-if.expect.md        |  9 ++-----
 .../compiler/interdependent.expect.md         |  8 ++----
 .../fixtures/compiler/inverted-if.expect.md   |  6 +----
 ...attribute-with-jsx-element-value.expect.md |  9 +++----
 ...ute-with-jsx-fragment-value.flow.expect.md |  6 ++---
 .../compiler/jsx-empty-expression.expect.md   |  3 +--
 .../fixtures/compiler/jsx-fragment.expect.md  |  3 +--
 .../compiler/jsx-namespaced-name.expect.md    |  3 +--
 ...ctive-local-variable-member-expr.expect.md |  3 +--
 .../fixtures/compiler/jsx-spread.expect.md    |  7 ++---
 ...-tag-evaluation-order-non-global.expect.md | 12 +++------
 .../jsx-tag-evaluation-order.expect.md        |  3 +--
 .../jsx-ternary-local-variable.expect.md      |  3 +--
 .../lambda-capture-returned-alias.expect.md   |  7 ++---
 ...mutated-non-reactive-to-reactive.expect.md |  6 ++---
 .../logical-expression-object.expect.md       |  4 +--
 .../maybe-mutate-object-in-callback.expect.md |  3 +--
 ...merge-consecutive-scopes-objects.expect.md | 13 +++------
 .../merge-consecutive-scopes.expect.md        | 10 +++----
 ...e-nested-scopes-with-same-inputs.expect.md |  3 +--
 .../compiler/method-call-computed.expect.md   | 11 +++-----
 .../compiler/method-call-fn-call.expect.md    |  8 ++----
 .../fixtures/compiler/method-call.expect.md   |  7 ++---
 ...-expr-export-default-gating-test.expect.md |  3 +--
 ...ti-arrow-expr-export-gating-test.expect.md |  3 +--
 .../multi-arrow-expr-gating-test.expect.md    |  3 +--
 ...ed-function-shadowed-identifiers.expect.md |  4 +--
 .../nested-optional-member-expr.expect.md     |  3 +--
 .../fixtures/compiler/new-spread.expect.md    |  4 +--
 .../noAlias-filter-on-array-prop.expect.md    |  3 +--
 .../obj-literal-cached-in-if-else.expect.md   |  6 ++---
 ...bj-literal-mutated-after-if-else.expect.md |  4 +--
 ...mutated-after-if-else-with-alias.expect.md |  3 +--
 .../obj-mutated-after-if-else.expect.md       |  3 +--
 ...-after-nested-if-else-with-alias.expect.md |  4 +--
 ...ct-expression-string-literal-key.expect.md |  3 +--
 .../object-literal-spread-element.expect.md   |  3 +--
 .../compiler/object-pattern-params.expect.md  | 10 +++----
 .../object-shorthand-method-1.expect.md       |  6 ++---
 .../object-shorthand-method-2.expect.md       | 10 +++----
 .../compiler/optional-call-chained.expect.md  |  3 +--
 .../compiler/optional-call-logical.expect.md  |  3 +--
 .../compiler/optional-call-simple.expect.md   |  3 +--
 ...ith-independently-memoizable-arg.expect.md |  3 +--
 ...call-with-optional-property-load.expect.md |  3 +--
 .../fixtures/compiler/optional-call.expect.md |  3 +--
 ...ional-computed-member-expression.expect.md |  7 ++---
 ...mber-expression-call-as-property.expect.md |  4 +--
 ...optional-member-expression-chain.expect.md |  4 +--
 ...optional-member-expr-as-property.expect.md |  4 +--
 .../compiler/optional-method-call.expect.md   |  3 +--
 .../optional-receiver-method-call.expect.md   |  3 +--
 ...ptional-receiver-optional-method.expect.md |  3 +--
 ...ng-scopes-shadowing-within-block.expect.md | 12 +++------
 .../overlapping-scopes-within-block.expect.md |  9 ++-----
 .../phi-type-inference-array-push.expect.md   |  7 ++---
 ...hi-type-inference-property-store.expect.md |  8 ++----
 .../primitive-as-dep-nested-scope.expect.md   | 11 +++-----
 .../compiler/primitive-as-dep.expect.md       |  3 +--
 .../prop-capturing-function-1.expect.md       |  7 ++---
 .../compiler/property-assignment.expect.md    |  7 ++---
 .../compiler/property-call-spread.expect.md   |  4 +--
 .../compiler/react-namespace.expect.md        |  7 ++---
 ...properties-inside-optional-chain.expect.md |  3 +--
 .../compiler/reactive-scopes-if.expect.md     | 11 +++-----
 .../compiler/reactive-scopes.expect.md        |  7 ++---
 ...-analysis-interleaved-reactivity.expect.md |  9 +++----
 ...ve-via-mutation-of-computed-load.expect.md | 11 +++-----
 ...ve-via-mutation-of-property-load.expect.md | 10 +++----
 ...ject-method-calls-mutable-lambda.expect.md |  3 +--
 .../readonly-object-method-calls.expect.md    |  6 ++---
 ...-in-returned-function-expression.expect.md |  3 +--
 .../reassignment-conditional.expect.md        |  9 ++-----
 .../reassignment-separate-scopes.expect.md    | 16 ++++-------
 .../fixtures/compiler/reassignment.expect.md  |  8 ++----
 ...-reactive-cond-deps-cfg-condexpr.expect.md |  4 +--
 ...ce-reactive-cond-deps-cfg-ifelse.expect.md |  4 +--
 ...d-deps-cfg-nested-ifelse-missing.expect.md |  4 +--
 ...tive-cond-deps-cfg-nested-ifelse.expect.md |  4 +--
 ...-cond-deps-cfg-nested-testifelse.expect.md |  4 +--
 ...ond-deps-cfg-switch-missing-case.expect.md |  4 +--
 ...-deps-cfg-switch-missing-default.expect.md |  4 +--
 ...ce-reactive-cond-deps-cfg-switch.expect.md |  4 +--
 ...uce-reactive-cond-deps-no-uncond.expect.md |  4 +--
 ...eactive-cond-deps-promote-uncond.expect.md |  4 +--
 ...eactive-cond-deps-subpath-order1.expect.md |  4 +--
 ...eactive-cond-deps-subpath-order2.expect.md |  4 +--
 ...ctive-cond-deps-superpath-order1.expect.md |  4 +--
 ...ctive-cond-deps-superpath-order2.expect.md |  4 +--
 ...ce-reactive-cond-memberexpr-join.expect.md |  3 +--
 ...ncies-optional-member-expression.expect.md |  3 +--
 .../reduce-reactive-deps-cond-scope.expect.md |  6 ++---
 ...eps-join-uncond-scopes-cond-deps.expect.md | 10 +++----
 ...ncond-deps-nonoverlap-descendant.expect.md |  5 +---
 ...ve-uncond-deps-nonoverlap-direct.expect.md |  4 +--
 ...e-uncond-deps-overlap-descendant.expect.md |  3 +--
 ...ctive-uncond-deps-overlap-direct.expect.md |  3 +--
 ...ctive-uncond-deps-subpath-order1.expect.md |  3 +--
 ...ctive-uncond-deps-subpath-order2.expect.md |  3 +--
 ...ctive-uncond-deps-subpath-order3.expect.md |  3 +--
 ...-current-aliased-no-added-to-dep.expect.md |  3 +--
 ...rrent-aliased-not-added-to-dep-2.expect.md |  6 ++---
 ...f-current-field-not-added-to-dep.expect.md |  3 +--
 .../ref-current-not-added-to-dep-2.expect.md  |  6 ++---
 .../ref-current-not-added-to-dep.expect.md    |  3 +--
 ...t-optional-field-no-added-to-dep.expect.md |  3 +--
 ...f-current-write-not-added-to-dep.expect.md |  3 +--
 .../fixtures/compiler/ref-in-effect.expect.md |  3 +--
 ...repro-duplicate-import-specifier.expect.md |  3 +--
 ...on-from-merge-consecutive-scopes.expect.md |  3 +--
 ...o-variable-without-mutable-range.expect.md | 11 +++-----
 ...epro-scope-missing-mutable-range.expect.md |  3 +--
 .../fixtures/compiler/repro.expect.md         |  7 ++---
 .../rest-param-with-array-pattern.expect.md   |  4 +--
 .../rest-param-with-identifier.expect.md      |  4 +--
 ...param-with-object-spread-pattern.expect.md |  4 +--
 .../rules-of-hooks-9a47e97b5d13.expect.md     |  4 +--
 .../rules-of-hooks-e66a744cffbe.expect.md     |  4 +--
 .../rules-of-hooks-eacfcaa6ef89.expect.md     |  3 +--
 ...s-dep-and-redeclare-maybe-frozen.expect.md | 20 ++++----------
 ...me-variable-as-dep-and-redeclare.expect.md | 19 ++++---------
 .../fixtures/compiler/simple-scope.expect.md  |  3 +--
 .../fixtures/compiler/simple.expect.md        |  6 ++---
 .../ssa-cascading-eliminated-phis.expect.md   |  3 +--
 .../compiler/ssa-leave-case.expect.md         |  7 ++---
 ...a-property-alias-alias-mutate-if.expect.md |  3 +--
 .../compiler/ssa-property-alias-if.expect.md  |  3 +--
 .../ssa-property-alias-mutate-if.expect.md    |  3 +--
 ...-property-alias-mutate-inside-if.expect.md |  3 +--
 ...ernary-destruction-with-mutation.expect.md |  3 +--
 ...ssa-renaming-ternary-destruction.expect.md |  3 +--
 ...a-renaming-ternary-with-mutation.expect.md |  3 +--
 .../compiler/ssa-renaming-ternary.expect.md   |  3 +--
 ...onditional-ternary-with-mutation.expect.md |  3 +--
 ...a-renaming-unconditional-ternary.expect.md |  3 +--
 ...ming-unconditional-with-mutation.expect.md |  3 +--
 ...-via-destructuring-with-mutation.expect.md |  3 +--
 .../ssa-renaming-via-destructuring.expect.md  |  6 ++---
 .../ssa-renaming-with-mutation.expect.md      |  3 +--
 .../fixtures/compiler/ssa-renaming.expect.md  |  6 ++---
 .../switch-non-final-default.expect.md        | 10 +++----
 .../fixtures/compiler/switch.expect.md        | 10 +++----
 ...temporary-accessed-outside-scope.expect.md |  7 ++---
 ...emporary-at-start-of-value-block.expect.md |  3 +--
 ...erty-load-accessed-outside-scope.expect.md |  7 ++---
 ...sion-captures-value-later-frozen.expect.md |  6 ++---
 .../try-catch-mutate-outer-value.expect.md    |  3 +--
 ...value-modified-in-catch-escaping.expect.md |  4 +--
 .../try-catch-within-mutable-range.expect.md  |  3 +--
 .../type-cast-expression.flow.expect.md       |  3 +--
 .../fixtures/compiler/unary-expr.expect.md    | 17 ++++++------
 .../unused-object-element-with-rest.expect.md |  3 +--
 .../update-expression-in-sequence.expect.md   |  6 +----
 ...expression-on-function-parameter.expect.md | 21 ++++++++-------
 .../compiler/update-expression.expect.md      |  5 +---
 .../compiler/use-callback-simple.expect.md    |  6 ++---
 ...maybe-mutate-context-in-callback.expect.md |  7 ++---
 ...context-in-callback-if-condition.expect.md |  9 +++----
 ...Context-read-context-in-callback.expect.md |  7 ++---
 .../compiler/useEffect-arg-memoized.expect.md |  6 ++---
 .../useEffect-nested-lambdas.expect.md        |  3 +--
 .../useMemo-if-else-multiple-return.expect.md |  6 ++---
 ...seMemo-independently-memoizeable.expect.md | 14 +++-------
 .../useMemo-inlining-block-return.expect.md   |  3 +--
 .../useMemo-multiple-if-else.expect.md        |  3 +--
 .../compiler/useMemo-simple.expect.md         |  6 ++---
 330 files changed, 554 insertions(+), 1262 deletions(-)

diff --git a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/CodegenReactiveFunction.ts b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/CodegenReactiveFunction.ts
index 5b2873c4e2..8a65ea14bc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/CodegenReactiveFunction.ts
+++ b/compiler/packages/babel-plugin-react-forget/src/ReactiveScopes/CodegenReactiveFunction.ts
@@ -237,28 +237,17 @@ function codegenMemoBlockForReactiveScope(
 ): void {
   const cacheStoreStatements: Array<t.Statement> = [];
   const cacheLoadStatements: Array<t.Statement> = [];
-  const changeIdentifiers: Array<t.Identifier> = [];
+  const changeExpressions: Array<t.Expression> = [];
   for (const dep of scope.dependencies) {
     const index = cx.nextCacheIndex;
-    const changeIdentifier = t.identifier(`c_${index}`);
     const depValue = codegenDependency(cx, dep);
 
-    changeIdentifiers.push(changeIdentifier);
-    statements.push(
-      t.variableDeclaration("const", [
-        t.variableDeclarator(
-          changeIdentifier,
-          t.binaryExpression(
-            "!==",
-            t.memberExpression(
-              t.identifier("$"),
-              t.numericLiteral(index),
-              true
-            ),
-            depValue
-          )
-        ),
-      ])
+    changeExpressions.push(
+      t.binaryExpression(
+        "!==",
+        t.memberExpression(t.identifier("$"), t.numericLiteral(index), true),
+        depValue
+      )
     );
     cacheStoreStatements.push(
       t.expressionStatement(
@@ -336,7 +325,7 @@ function codegenMemoBlockForReactiveScope(
       )
     );
   }
-  let testCondition = (changeIdentifiers as Array<t.Expression>).reduce(
+  let testCondition = (changeExpressions as Array<t.Expression>).reduce(
     (acc: t.Expression | null, ident: t.Expression) => {
       if (acc == null) {
         return ident;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-computed-load.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-computed-load.expect.md
index 44b8a6a030..29853e3896 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-computed-load.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-computed-load.expect.md
@@ -19,9 +19,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = { a };
     const y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-while.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-while.expect.md
index 1c979ac82c..7952cedc67 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-while.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/alias-while.expect.md
@@ -29,9 +29,8 @@ function mutate(x, y) {}
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(cond) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== cond;
   let a;
-  if (c_0) {
+  if ($[0] !== cond) {
     a = {};
     let b = {};
     let c = {};
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
index 63e8ffaafa..d321e844b3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep-nested-scope.expect.md
@@ -25,17 +25,14 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // bar(props.b) i
 //   - y depends on either bar(props.b) or bar(props.b) + 1
 function AllocatingPrimitiveAsDepNested(props) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== props.b;
-  const c_1 = $[1] !== props.a;
   let x;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== props.b || $[1] !== props.a) {
     x = {};
     mutate(x);
     const t0 = bar(props.b) + 1;
-    const c_4 = $[4] !== t0;
     let t1;
-    if (c_4) {
+    if ($[4] !== t0) {
       t1 = foo(t0);
       $[4] = t0;
       $[5] = t1;
@@ -52,10 +49,8 @@ function AllocatingPrimitiveAsDepNested(props) {
     x = $[2];
     y = $[3];
   }
-  const c_6 = $[6] !== x;
-  const c_7 = $[7] !== y;
   let t2;
-  if (c_6 || c_7) {
+  if ($[6] !== x || $[7] !== y) {
     t2 = [x, y];
     $[6] = x;
     $[7] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep.expect.md
index e7831baf83..b06e1e47b4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allocating-primitive-as-dep.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // bar(props.b) i
 function AllocatingPrimitiveAsDep(props) {
   const $ = useMemoCache(2);
   const t0 = bar(props).b + 1;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = foo(t0);
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allow-passing-refs-as-props.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allow-passing-refs-as-props.expect.md
index 022d17f16f..d3a8ef511a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allow-passing-refs-as-props.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/allow-passing-refs-as-props.expect.md
@@ -16,9 +16,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const ref = useRef(null);
-  const c_0 = $[0] !== ref;
   let t0;
-  if (c_0) {
+  if ($[0] !== ref) {
     t0 = <Foo ref={ref} />;
     $[0] = ref;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
index eb37eac767..ace266beae 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-access-assignment.expect.md
@@ -25,16 +25,12 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(10);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
   let z;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [a];
-    const c_5 = $[5] !== b;
     let t0;
-    if (c_5) {
+    if ($[5] !== b) {
       t0 = [null, b];
       $[5] = b;
       $[6] = t0;
@@ -54,10 +50,8 @@ function foo(a, b, c) {
     x = $[3];
     z = $[4];
   }
-  const c_7 = $[7] !== x;
-  const c_8 = $[8] !== z;
   let t1;
-  if (c_7 || c_8) {
+  if ($[7] !== x || $[8] !== z) {
     t1 = [x, z];
     $[7] = x;
     $[8] = z;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-closure.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-closure.expect.md
index 330045c423..0429688072 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-closure.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-closure.expect.md
@@ -20,9 +20,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.x;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.x) {
     t0 = foo(props.x);
     $[0] = props.x;
     $[1] = t0;
@@ -30,10 +29,8 @@ function Component(props) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== props;
-  const c_3 = $[3] !== x;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== props || $[3] !== x) {
     t1 = function () {
       const arr = [...bar(props)];
       return arr.at(x);
@@ -45,9 +42,8 @@ function Component(props) {
     t1 = $[4];
   }
   const fn = t1;
-  const c_5 = $[5] !== fn;
   let t2;
-  if (c_5) {
+  if ($[5] !== fn) {
     t2 = fn();
     $[5] = fn;
     $[6] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
index 786fb20054..e551b5d439 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-at-effect.expect.md
@@ -23,18 +23,16 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // arrayInstance.
 //  - mutate on lvalue
 function ArrayAtTest(props) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== props.x;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.x) {
     t0 = foo(props.x);
     $[0] = props.x;
     $[1] = t0;
   } else {
     t0 = $[1];
   }
-  const c_2 = $[2] !== t0;
   let t1;
-  if (c_2) {
+  if ($[2] !== t0) {
     t1 = [t0];
     $[2] = t0;
     $[3] = t1;
@@ -42,13 +40,10 @@ function ArrayAtTest(props) {
     t1 = $[3];
   }
   const arr = t1;
-  const c_4 = $[4] !== props.y;
-  const c_5 = $[5] !== arr;
   let t3;
-  if (c_4 || c_5) {
-    const c_7 = $[7] !== props.y;
+  if ($[4] !== props.y || $[5] !== arr) {
     let t2;
-    if (c_7) {
+    if ($[7] !== props.y) {
       t2 = bar(props.y);
       $[7] = props.y;
       $[8] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-expression-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-expression-spread.expect.md
index bce6e3d794..615ac70f4f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-expression-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-expression-spread.expect.md
@@ -21,10 +21,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.foo;
-  const c_1 = $[1] !== props.bar;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props.foo || $[1] !== props.bar) {
     t0 = [0, ...props.foo, null, ...props.bar, "z"];
     $[0] = props.foo;
     $[1] = props.bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-join.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-join.expect.md
index 0ce1b81ccc..7504faa7b2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-join.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-join.expect.md
@@ -28,9 +28,8 @@ function Component(props) {
     t0 = $[0];
     t1 = $[1];
   }
-  const c_2 = $[2] !== props.value;
   let t2;
-  if (c_2) {
+  if ($[2] !== props.value) {
     t2 = [t0, t1, props.value];
     $[2] = props.value;
     $[3] = t2;
@@ -47,10 +46,8 @@ function Component(props) {
   }
   const y = x.join(t3);
   foo(y);
-  const c_5 = $[5] !== x;
-  const c_6 = $[6] !== y;
   let t4;
-  if (c_5 || c_6) {
+  if ($[5] !== x || $[6] !== y) {
     t4 = [x, y];
     $[5] = x;
     $[6] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-captures-receiver-noAlias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-captures-receiver-noAlias.expect.md
index b83e08b90f..c07c8742dd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-captures-receiver-noAlias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-captures-receiver-noAlias.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     const item = { a: props.a };
     const items = [item];
     t0 = items.map((item_0) => item_0);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-noAlias-escaping-function.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-noAlias-escaping-function.expect.md
index af22a304df..9105970f7f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-noAlias-escaping-function.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-map-noAlias-escaping-function.expect.md
@@ -30,9 +30,8 @@ function Component(props) {
     t0 = $[0];
   }
   const f = t0;
-  const c_1 = $[1] !== props.items;
   let t1;
-  if (c_1) {
+  if ($[1] !== props.items) {
     t1 = [...props.items].map(f);
     $[1] = props.items;
     $[2] = t1;
@@ -40,9 +39,8 @@ function Component(props) {
     t1 = $[2];
   }
   const x = t1;
-  const c_3 = $[3] !== x;
   let t2;
-  if (c_3) {
+  if ($[3] !== x) {
     t2 = [x, f];
     $[3] = x;
     $[4] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-pattern-params.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-pattern-params.expect.md
index 71c3d478bb..fd86a88849 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-pattern-params.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-pattern-params.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t16) {
   const $ = useMemoCache(7);
   const [a, b] = t16;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -33,9 +32,8 @@ function component(t16) {
     t0 = $[1];
   }
   const y = t0;
-  const c_2 = $[2] !== b;
   let t1;
-  if (c_2) {
+  if ($[2] !== b) {
     t1 = { b };
     $[2] = b;
     $[3] = t1;
@@ -43,10 +41,8 @@ function component(t16) {
     t1 = $[3];
   }
   const z = t1;
-  const c_4 = $[4] !== y;
-  const c_5 = $[5] !== z;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== y || $[5] !== z) {
     t2 = [y, z];
     $[4] = y;
     $[5] = z;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-properties.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-properties.expect.md
index 7038f7b1c7..72b8cd76df 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-properties.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-properties.expect.md
@@ -23,10 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     t0 = [props.a, props.b, "hello"];
     $[0] = props.a;
     $[1] = props.b;
@@ -37,11 +35,8 @@ function Component(props) {
   const a = t0;
   const x = a.length;
   const y = a.push;
-  const c_3 = $[3] !== a;
-  const c_4 = $[4] !== x;
-  const c_5 = $[5] !== y;
   let t1;
-  if (c_3 || c_4 || c_5) {
+  if ($[3] !== a || $[4] !== x || $[5] !== y) {
     t1 = { a, x, y, z: a.concat };
     $[3] = a;
     $[4] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-property-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-property-call.expect.md
index 8a0bcdb0e6..e5412424d3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-property-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-property-call.expect.md
@@ -24,11 +24,9 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(11);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let t0;
   let a;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     a = [props.a, props.b, "hello"];
     t0 = a.push(42);
     $[0] = props.a;
@@ -40,10 +38,8 @@ function Component(props) {
     a = $[3];
   }
   const x = t0;
-  const c_4 = $[4] !== a;
-  const c_5 = $[5] !== props.c;
   let t1;
-  if (c_4 || c_5) {
+  if ($[4] !== a || $[5] !== props.c) {
     t1 = a.at(props.c);
     $[4] = a;
     $[5] = props.c;
@@ -52,11 +48,8 @@ function Component(props) {
     t1 = $[6];
   }
   const y = t1;
-  const c_7 = $[7] !== a;
-  const c_8 = $[8] !== x;
-  const c_9 = $[9] !== y;
   let t2;
-  if (c_7 || c_8 || c_9) {
+  if ($[7] !== a || $[8] !== x || $[9] !== y) {
     t2 = { a, x, y };
     $[7] = a;
     $[8] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-push-effect.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-push-effect.expect.md
index 2366c7cb86..8e0ab318d8 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-push-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/array-push-effect.expect.md
@@ -24,9 +24,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // arrayInstance.
 //  - mutate on receiver
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.x;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.x) {
     t0 = foo(props.x);
     $[0] = props.x;
     $[1] = t0;
@@ -34,9 +33,8 @@ function Component(props) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== props.y;
   let t1;
-  if (c_2) {
+  if ($[2] !== props.y) {
     t1 = { y: props.y };
     $[2] = props.y;
     $[3] = t1;
@@ -44,10 +42,8 @@ function Component(props) {
     t1 = $[3];
   }
   const y = t1;
-  const c_4 = $[4] !== x;
-  const c_5 = $[5] !== y;
   let arr;
-  if (c_4 || c_5) {
+  if ($[4] !== x || $[5] !== y) {
     arr = [];
     let t2;
     if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/arrow-function-expr-gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/arrow-function-expr-gating-test.expect.md
index 78152a3bba..9b2998ed97 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/arrow-function-expr-gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/arrow-function-expr-gating-test.expect.md
@@ -17,9 +17,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating
 const ErrorView = isForgetEnabled_Fixtures()
   ? (error, _retry) => {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== error;
       let t0;
-      if (c_0) {
+      if ($[0] !== error) {
         t0 = <MessageBox error={error} />;
         $[0] = error;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-computed.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-computed.expect.md
index 33230b0871..9c069b3cd2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-computed.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-computed.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.x;
   let x;
-  if (c_0) {
+  if ($[0] !== props.x) {
     x = [props.x];
 
     x[0] = x[0] * 2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-nested-path.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-nested-path.expect.md
index e38d0776f2..dbb715b8cc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-nested-path.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/assignment-expression-nested-path.expect.md
@@ -23,9 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function g(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.c;
   let a;
-  if (c_0) {
+  if ($[0] !== props.c) {
     a = { b: { c: props.c } };
     a.b.c = a.b.c + 1;
     a.b.c = a.b.c * 2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await-side-effecting-promise.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await-side-effecting-promise.expect.md
index 5ad3a3e801..e53405a71f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await-side-effecting-promise.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await-side-effecting-promise.expect.md
@@ -16,9 +16,8 @@ async function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 async function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.id;
   let x;
-  if (c_0) {
+  if ($[0] !== props.id) {
     x = [];
     await populateData(props.id, x);
     $[0] = props.id;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await.expect.md
index 42176f985d..1a2c0798aa 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/await.expect.md
@@ -15,9 +15,8 @@ async function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 async function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.id;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.id) {
     t0 = await load(props.id);
     $[0] = props.id;
     $[1] = t0;
@@ -25,9 +24,8 @@ async function Component(props) {
     t0 = $[1];
   }
   const user = t0;
-  const c_2 = $[2] !== user.name;
   let t1;
-  if (c_2) {
+  if ($[2] !== user.name) {
     t1 = <div>{user.name}</div>;
     $[2] = user.name;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
index 7a9fbce63e..55c97f0a6d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-import.expect.md
@@ -33,9 +33,8 @@ function Component(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
   let t35;
-  const c_0 = $[0] !== x;
   let t0;
-  if (c_0) {
+  if ($[0] !== x) {
     t0 = calculateExpensiveNumber(x);
     $[0] = x;
     $[1] = t0;
@@ -44,9 +43,8 @@ function Component(props) {
   }
   t35 = t0;
   const expensiveNumber = t35;
-  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if (c_2) {
+  if ($[2] !== expensiveNumber) {
     t1 = <div>{expensiveNumber}</div>;
     $[2] = expensiveNumber;
     $[3] = t1;
@@ -60,9 +58,8 @@ function Component2(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
   let t35;
-  const c_0 = $[0] !== x;
   let t0;
-  if (c_0) {
+  if ($[0] !== x) {
     t0 = calculateExpensiveNumber(x);
     $[0] = x;
     $[1] = t0;
@@ -71,9 +68,8 @@ function Component2(props) {
   }
   t35 = t0;
   const expensiveNumber = t35;
-  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if (c_2) {
+  if ($[2] !== expensiveNumber) {
     t1 = <div>{expensiveNumber}</div>;
     $[2] = expensiveNumber;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
index db03ab401a..2c5e9f66ca 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-kitchensink-import.expect.md
@@ -35,9 +35,8 @@ function Component(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
   let t35;
-  const c_0 = $[0] !== x;
   let t0;
-  if (c_0) {
+  if ($[0] !== x) {
     t0 = calculateExpensiveNumber(x);
     $[0] = x;
     $[1] = t0;
@@ -46,9 +45,8 @@ function Component(props) {
   }
   t35 = t0;
   const expensiveNumber = t35;
-  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if (c_2) {
+  if ($[2] !== expensiveNumber) {
     t1 = <div>{expensiveNumber}</div>;
     $[2] = expensiveNumber;
     $[3] = t1;
@@ -62,9 +60,8 @@ function Component2(props) {
   const $ = useMemoCache(4);
   const [x] = useState(0);
   let t35;
-  const c_0 = $[0] !== x;
   let t0;
-  if (c_0) {
+  if ($[0] !== x) {
     t0 = calculateExpensiveNumber(x);
     $[0] = x;
     $[1] = t0;
@@ -73,9 +70,8 @@ function Component2(props) {
   }
   t35 = t0;
   const expensiveNumber = t35;
-  const c_2 = $[2] !== expensiveNumber;
   let t1;
-  if (c_2) {
+  if ($[2] !== expensiveNumber) {
     t1 = <div>{expensiveNumber}</div>;
     $[2] = expensiveNumber;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
index 03bc5e12db..a4a94cb310 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/babel-existing-react-namespace-import.expect.md
@@ -32,9 +32,8 @@ function Component(props) {
   let t39;
   t39 = calculateExpensiveNumber(x);
   const expensiveNumber = t39;
-  const c_0 = $[0] !== expensiveNumber;
   let t0;
-  if (c_0) {
+  if ($[0] !== expensiveNumber) {
     t0 = <div>{expensiveNumber}</div>;
     $[0] = expensiveNumber;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
index 8151afa038..c35529e029 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug.useMemo-deps-array-not-cleared.expect.md
@@ -30,9 +30,8 @@ function App(t23) {
 
   hasDeps ? null : [text];
   let t44;
-  const c_0 = $[0] !== text;
   let t0;
-  if (c_0) {
+  if ($[0] !== text) {
     t0 = text.toUpperCase();
     $[0] = text;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug_object-pattern.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug_object-pattern.expect.md
index 4bdda2e2aa..d20165ddc8 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug_object-pattern.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/bug_object-pattern.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t) {
   const $ = useMemoCache(2);
   const { a } = t;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-spread.expect.md
index d32100757b..da219eabac 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-spread.expect.md
@@ -15,10 +15,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     t0 = foo(...props.a, null, ...props.b);
     $[0] = props.a;
     $[1] = props.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
index ac3985eaff..052b76f042 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/call-with-independently-memoizable-arg.expect.md
@@ -20,13 +20,11 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props;
   let t1;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeFunction(props);
-    const c_2 = $[2] !== props.text;
     let t0;
-    if (c_2) {
+    if ($[2] !== props.text) {
       t0 = (
         <div>
           <span>{props.text}</span>
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias-iife.expect.md
index 57222d17f0..1a230a9371 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias-iife.expect.md
@@ -28,9 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = { a };
 
     const q = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias.expect.md
index 1fa9f50bdb..a746cdc88d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-indirect-mutate-alias.expect.md
@@ -30,9 +30,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = { a };
     const f0 = function () {
       const q = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-param-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-param-mutate.expect.md
index 328d6219e5..0279315454 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-param-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture-param-mutate.expect.md
@@ -48,9 +48,8 @@ function getNativeLogFunction(level) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function getNativeLogFunction(level) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== level;
   let t0;
-  if (c_0) {
+  if ($[0] !== level) {
     t0 = function () {
       let str = undefined;
       if (arguments.length === 1 && typeof arguments[0] === "string") {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns-iife.expect.md
index 9075d8227c..1e7dbb6f1b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns-iife.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let z;
-  if (c_0) {
+  if ($[0] !== a) {
     z = { a };
 
     (function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns.expect.md
index 2ef607c8e1..e94dffda47 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capture_mutate-across-fns.expect.md
@@ -28,9 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let z;
-  if (c_0) {
+  if ($[0] !== a) {
     z = { a };
     const f0 = function () {
       const f1 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-arrow-function-1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-arrow-function-1.expect.md
index c35ba9bf14..c609191d27 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-arrow-function-1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-arrow-function-1.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -34,9 +33,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = () => {
       console.log(z);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2-iife.expect.md
index a7a73a9634..8dced458d9 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2-iife.expect.md
@@ -31,10 +31,8 @@ import { mutate } from "shared-runtime";
 
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     x = { foo };
     const y = { bar };
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2.expect.md
index d32fdd146e..4e994cfb63 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-2.expect.md
@@ -23,10 +23,8 @@ function component(foo, bar) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     x = { foo };
     const y = { bar };
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2-iife.expect.md
index 6c7a08d7f5..92af83e719 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2-iife.expect.md
@@ -31,10 +31,8 @@ const { mutate } = require("shared-runtime");
 
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     x = { foo };
     const y = { bar };
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2.expect.md
index 6dfb8707a0..b6ce0d6667 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-fun-alias-captured-mutate-arr-2.expect.md
@@ -23,10 +23,8 @@ function component(foo, bar) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     x = { foo };
     const y = { bar };
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr-iife.expect.md
index e8e6df8f43..0d3e5fbb13 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr-iife.expect.md
@@ -31,10 +31,8 @@ const { mutate } = require("shared-runtime");
 
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     const x = { foo };
     y = { bar };
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr.expect.md
index 90526c7bc6..f919bcd5f0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-arr.expect.md
@@ -23,10 +23,8 @@ function component(foo, bar) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     const x = { foo };
     y = { bar };
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-iife.expect.md
index a94c12ac82..7e1f61b513 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate-iife.expect.md
@@ -31,10 +31,8 @@ const { mutate } = require("shared-runtime");
 
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     const x = { foo };
     y = { bar };
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate.expect.md
index 213bea05df..0c8f940d08 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-captured-mutate.expect.md
@@ -23,10 +23,8 @@ function component(foo, bar) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(foo, bar) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     const x = { foo };
     y = { bar };
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate-iife.expect.md
index 68b8296b87..464e58475f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate-iife.expect.md
@@ -29,9 +29,8 @@ const { mutate } = require("shared-runtime");
 
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate.expect.md
index e115efcf35..5e59e76b10 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-computed-mutate.expect.md
@@ -21,9 +21,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate-iife.expect.md
index a7d9adb964..d5cc78539b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate-iife.expect.md
@@ -29,9 +29,8 @@ const { mutate } = require("shared-runtime");
 
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate.expect.md
index a1389d73a7..ded6a69e4d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-mutate.expect.md
@@ -21,9 +21,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate-iife.expect.md
index e6687b71f5..9347be5e7f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate-iife.expect.md
@@ -30,9 +30,8 @@ import { mutate } from "shared-runtime";
 
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate.expect.md
index 3bade6dab2..18ca65332c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-computed-mutate.expect.md
@@ -22,9 +22,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate-iife.expect.md
index 26f9308f21..08573715fe 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate-iife.expect.md
@@ -30,9 +30,8 @@ const { mutate } = require("shared-runtime");
 
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate.expect.md
index 7eb8182138..fbd7214574 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-alias-receiver-mutate.expect.md
@@ -22,9 +22,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-2.expect.md
index a694c4233b..2853503c65 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-2.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== b;
   let t0;
-  if (c_0) {
+  if ($[0] !== b) {
     t0 = { b };
     $[0] = b;
     $[1] = t0;
@@ -37,10 +36,8 @@ function component(a, b) {
     t0 = $[1];
   }
   const y = t0;
-  const c_2 = $[2] !== a;
-  const c_3 = $[3] !== y.b;
   let z;
-  if (c_2 || c_3) {
+  if ($[2] !== a || $[3] !== y.b) {
     z = { a };
     const x = function () {
       z.a = 2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-3.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-3.expect.md
index 00860cf875..b9b4754af7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-3.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-3.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-nested.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-nested.expect.md
index 2f385edd24..55916de57a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-nested.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate-nested.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     y = { b: { a } };
     const x = function () {
       y.b.a = 2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate.expect.md
index 1fd96e4230..2a426b8ac6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-mutate.expect.md
@@ -27,10 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let z;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     z = { a };
     const y = { b };
     const x = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias-iife.expect.md
index 1b4e8bd955..52a75942d2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias-iife.expect.md
@@ -29,9 +29,8 @@ const { mutate } = require("shared-runtime");
 
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias.expect.md
index 8fc678aedf..dbb9d829ad 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-func-simple-alias.expect.md
@@ -21,9 +21,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-1.expect.md
index 54ac22fd4e..46d7a9d324 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-1.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -34,9 +33,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = function () {
       console.log(z);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2-iife.expect.md
index 608d053ca1..b504f49445 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2-iife.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2.expect.md
index 5c981fbaba..7eab8e7005 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-2.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3-iife.expect.md
index f29b8495e2..f6dfc8e725 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3-iife.expect.md
@@ -28,10 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a, b) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     const x = [a, b];
     y = {};
     let t;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3.expect.md
index fad4cf4324..71a776211f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-3.expect.md
@@ -29,10 +29,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a, b) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     const x = [a, b];
     y = {};
     let t;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4-iife.expect.md
index 3dbc9ff32b..4583dec6fd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4-iife.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4.expect.md
index c188be70fb..a39ef3296e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-4.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-iife.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-iife.expect.md
index 1451d45247..b1135e090e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-iife.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load-iife.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load.expect.md
index 51832261fc..d34b24b05f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-alias-computed-load.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function bar(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = [a];
     y = {};
     const f0 = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-capture-ref-before-rename.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-capture-ref-before-rename.expect.md
index 76d2ef6f19..f2be885234 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-capture-ref-before-rename.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-capture-ref-before-rename.expect.md
@@ -25,9 +25,8 @@ function component(a, b) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== a;
   let z;
-  if (c_0) {
+  if ($[0] !== a) {
     z = { a };
 
     mutate(z);
@@ -38,9 +37,8 @@ function component(a, b) {
   }
 
   let y = z;
-  const c_2 = $[2] !== b;
   let t0;
-  if (c_2) {
+  if ($[2] !== b) {
     t0 = { b };
     $[2] = b;
     $[3] = t0;
@@ -48,10 +46,8 @@ function component(a, b) {
     t0 = $[3];
   }
   const z_0 = t0;
-  const c_4 = $[4] !== y;
-  const c_5 = $[5] !== z_0;
   let t1;
-  if (c_4 || c_5) {
+  if ($[4] !== y || $[5] !== z_0) {
     t1 = { y, z: z_0 };
     $[4] = y;
     $[5] = z_0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-conditional-capture-mutate.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-conditional-capture-mutate.expect.md
index 700a0094f1..731c860ec0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-conditional-capture-mutate.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-conditional-capture-mutate.expect.md
@@ -25,9 +25,8 @@ function component(a, b) {
 import { unstable_useMemoCache as useMemoCache } from "react"; // @debug
 function component(a, b) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -36,10 +35,8 @@ function component(a, b) {
   }
   const z = t0;
   const y = b;
-  const c_2 = $[2] !== y;
-  const c_3 = $[3] !== z;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== y || $[3] !== z) {
     t1 = function () {
       if (y) {
         maybeMutate(z);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-decl.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-decl.expect.md
index 3309e2ef87..21a5e1883e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-decl.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-decl.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t;
-  if (c_0) {
+  if ($[0] !== a) {
     t = { a };
     const x = function x() {
       t.foo();
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-arguments.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-arguments.expect.md
index 64a15a00d1..8a31cc99af 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-arguments.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-arguments.expect.md
@@ -21,9 +21,8 @@ function Foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.router.location;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.router.location) {
     t0 = (reason) => {
       log(props.router.location);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-call.expect.md
index 9d28478e70..c6a0e93ff2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-member-expr-call.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t26) {
   const $ = useMemoCache(7);
   const { mutator } = t26;
-  const c_0 = $[0] !== mutator;
   let t0;
-  if (c_0) {
+  if ($[0] !== mutator) {
     t0 = () => {
       mutator.poke();
     };
@@ -35,9 +34,8 @@ function component(t26) {
     t0 = $[1];
   }
   const poke = t0;
-  const c_2 = $[2] !== mutator.user;
   let t1;
-  if (c_2) {
+  if ($[2] !== mutator.user) {
     t1 = () => {
       mutator.user.hide();
     };
@@ -47,10 +45,8 @@ function component(t26) {
     t1 = $[3];
   }
   const hide = t1;
-  const c_4 = $[4] !== poke;
-  const c_5 = $[5] !== hide;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== poke || $[5] !== hide) {
     t2 = <Foo poke={poke} hide={hide} />;
     $[4] = poke;
     $[5] = hide;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-renamed-ref.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-renamed-ref.expect.md
index 346acbabcf..df3ffa8a86 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-renamed-ref.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-renamed-ref.expect.md
@@ -21,9 +21,8 @@ function component(a, b) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-runs-inference.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-runs-inference.expect.md
index c294e7eb01..b8f57f30e2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-runs-inference.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-runs-inference.expect.md
@@ -16,9 +16,8 @@ function component(a, b) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -26,9 +25,8 @@ function component(a, b) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = () => <Foo>{z}</Foo>;
     $[2] = z;
     $[3] = t1;
@@ -36,9 +34,8 @@ function component(a, b) {
     t1 = $[3];
   }
   const p = t1;
-  const c_4 = $[4] !== p;
   let t2;
-  if (c_4) {
+  if ($[4] !== p) {
     t2 = p();
     $[4] = p;
     $[5] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-skip-computed-path.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-skip-computed-path.expect.md
index d0c17b5936..061b098d68 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-skip-computed-path.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-skip-computed-path.expect.md
@@ -21,9 +21,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function StoreLandingUnseenGiftModalContainer(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     const giftsSeen = { a };
     t0 = ((gift) => (gift.id ? giftsSeen[gift.id] : false))();
     $[0] = a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-within-block.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-within-block.expect.md
index adb4d6371f..c615a47036 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-within-block.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-function-within-block.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -37,9 +36,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = function () {
       console.log(z);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-member-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-member-expr.expect.md
index cc3acf6c6c..24a795127d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-member-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-member-expr.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -34,9 +33,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z.a;
   let t1;
-  if (c_2) {
+  if ($[2] !== z.a) {
     t1 = function () {
       console.log(z.a);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-call.expect.md
index 9725ed6b7c..6143759583 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-call.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a: { a } };
     $[0] = a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr-in-nested-func.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr-in-nested-func.expect.md
index ec43972dd2..456c5aaeb6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr-in-nested-func.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr-in-nested-func.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a: { a } };
     $[0] = a;
     $[1] = t0;
@@ -36,9 +35,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z.a.a;
   let t1;
-  if (c_2) {
+  if ($[2] !== z.a.a) {
     t1 = function () {
       (function () {
         console.log(z.a.a);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr.expect.md
index 2be79b9fcb..e02f879899 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-nested-member-expr.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a: { a } };
     $[0] = a;
     $[1] = t0;
@@ -34,9 +33,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z.a.a;
   let t1;
-  if (c_2) {
+  if ($[2] !== z.a.a) {
     t1 = function () {
       console.log(z.a.a);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-reference-changes-type.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-reference-changes-type.expect.md
index 9eb3a2da1b..0fea81ee0a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-reference-changes-type.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-reference-changes-type.expect.md
@@ -20,9 +20,8 @@ function component(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let y;
-  if (c_0) {
+  if ($[0] !== a) {
     const x = { a };
     y = 1;
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-block.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-block.expect.md
index 66ca55f119..18e2f9c688 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-block.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-block.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -36,9 +35,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = function () {
       console.log(z);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-function.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-function.expect.md
index 2f7ad7de80..43b8a4f22e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-function.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/capturing-variable-in-nested-function.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -36,9 +35,8 @@ function component(a) {
     t0 = $[1];
   }
   const z = t0;
-  const c_2 = $[2] !== z;
   let t1;
-  if (c_2) {
+  if ($[2] !== z) {
     t1 = function () {
       (function () {
         console.log(z);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-imports-same-source.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-imports-same-source.expect.md
index 501f56c6f3..1ee3b6a5a6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-imports-same-source.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-imports-same-source.expect.md
@@ -19,9 +19,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @enableEmitFre
 function useFoo(props) {
   if (__DEV__) useRenderCounter("useFoo");
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.x;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.x) {
     t0 = foo(props.x);
     $[0] = props.x;
     $[1] = __DEV__ ? makeReadOnly(t0, "useFoo") : t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-make-read-only.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-make-read-only.expect.md
index 4b6eb10ce8..0de0951ade 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-make-read-only.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-emit-make-read-only.expect.md
@@ -24,10 +24,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @enableEmitFre
 
 function MyComponentName(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     x = {};
     foo(x, props.a);
     foo(x, props.b);
@@ -37,9 +35,8 @@ function MyComponentName(props) {
   } else {
     x = $[2];
   }
-  const c_3 = $[3] !== x;
   let y;
-  if (c_3) {
+  if ($[3] !== x) {
     y = [];
     y.push(x);
     $[3] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-gating-test.expect.md
index 811d188e52..559bc6dc96 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-gating-test.expect.md
@@ -30,9 +30,8 @@ const Bar = isForgetEnabled_Fixtures()
   ? function Bar(props) {
       if (__DEV__) useRenderCounter("Bar");
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <div>{props.bar}</div>;
         $[0] = props.bar;
         $[1] = t0;
@@ -54,9 +53,8 @@ const Foo = isForgetEnabled_Fixtures()
   ? function Foo(props) {
       if (__DEV__) useRenderCounter("Foo");
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <Foo>{props.bar}</Foo>;
         $[0] = props.bar;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md
index b7bbb65fc9..d03a97a01e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/codegen-instrument-forget-test.expect.md
@@ -29,9 +29,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @instrumentFor
 function Bar(props) {
   if (__DEV__) useRenderCounter("Bar");
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     t0 = <div>{props.bar}</div>;
     $[0] = props.bar;
     $[1] = t0;
@@ -48,9 +47,8 @@ function NoForget(props) {
 function Foo(props) {
   if (__DEV__) useRenderCounter("Foo");
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     t0 = <Foo>{props.bar}</Foo>;
     $[0] = props.bar;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component-declaration-basic.flow.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component-declaration-basic.flow.expect.md
index ad9dd87947..dd0f79f6ab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component-declaration-basic.flow.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component-declaration-basic.flow.expect.md
@@ -17,9 +17,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 export default function Foo(t7) {
   const $ = useMemoCache(2);
   const { bar } = t7;
-  const c_0 = $[0] !== bar;
   let t0;
-  if (c_0) {
+  if ($[0] !== bar) {
     t0 = <Bar bar={bar} />;
     $[0] = bar;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component.expect.md
index 172978eb00..960f68fa7f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/component.expect.md
@@ -45,10 +45,8 @@ function Component(props) {
   const $ = useMemoCache(8);
   const items = props.items;
   const maxItems = props.maxItems;
-  const c_0 = $[0] !== maxItems;
-  const c_1 = $[1] !== items;
   let renderedItems;
-  if (c_0 || c_1) {
+  if ($[0] !== maxItems || $[1] !== items) {
     renderedItems = [];
     const seen = new Set();
     const max = Math.max(0, maxItems);
@@ -72,19 +70,16 @@ function Component(props) {
   }
 
   const count = renderedItems.length;
-  const c_3 = $[3] !== count;
   let t0;
-  if (c_3) {
+  if ($[3] !== count) {
     t0 = <h1>{count} Items</h1>;
     $[3] = count;
     $[4] = t0;
   } else {
     t0 = $[4];
   }
-  const c_5 = $[5] !== t0;
-  const c_6 = $[6] !== renderedItems;
   let t1;
-  if (c_5 || c_6) {
+  if ($[5] !== t0 || $[6] !== renderedItems) {
     t1 = (
       <div>
         {t0}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-call-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-call-spread.expect.md
index 04af67209d..6f5a492608 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-call-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-call-spread.expect.md
@@ -15,11 +15,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.method;
-  const c_1 = $[1] !== props.a;
-  const c_2 = $[2] !== props.b;
   let t0;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.method || $[1] !== props.a || $[2] !== props.b) {
     t0 = foo[props.method](...props.a, null, ...props.b);
     $[0] = props.method;
     $[1] = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-load-primitive-as-dependency.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-load-primitive-as-dependency.expect.md
index 2f9e6f6f57..bcf4cbc25e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-load-primitive-as-dependency.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-load-primitive-as-dependency.expect.md
@@ -23,9 +23,8 @@ function Component(props) {
   const a = foo();
 
   const t0 = a[props.a] + 1;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = bar(t0);
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-store-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-store-alias.expect.md
index d2c9a0e405..b0e238605e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-store-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/computed-store-alias.expect.md
@@ -18,10 +18,8 @@ function component(a, b) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     const y = { a };
     x = { b };
     x.y = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/concise-arrow-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/concise-arrow-expr.expect.md
index 9f31cdb980..0316beccaf 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/concise-arrow-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/concise-arrow-expr.expect.md
@@ -25,9 +25,8 @@ function component() {
     t0 = $[0];
   }
   const handler = t0;
-  const c_1 = $[1] !== handler;
   let t1;
-  if (c_1) {
+  if ($[1] !== handler) {
     t1 = <Foo handler={handler} />;
     $[1] = handler;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/cond-deps-conditional-member-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/cond-deps-conditional-member-expr.expect.md
index b875068280..3c07349194 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/cond-deps-conditional-member-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/cond-deps-conditional-member-expr.expect.md
@@ -29,9 +29,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // To preserve th
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = [];
     x.push(props.a?.b);
     $[0] = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break-labeled.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break-labeled.expect.md
index 9857e371f1..2f5773825e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break-labeled.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break-labeled.expect.md
@@ -35,12 +35,13 @@ import { unstable_useMemoCache as useMemoCache } from "react";
  */
 function Component(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
-  const c_2 = $[2] !== props.c;
-  const c_3 = $[3] !== props.d;
   let a;
-  if (c_0 || c_1 || c_2 || c_3) {
+  if (
+    $[0] !== props.a ||
+    $[1] !== props.b ||
+    $[2] !== props.c ||
+    $[3] !== props.d
+  ) {
     a = [];
     a.push(props.a);
     bb1: {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break.expect.md
index c2637c7b16..76fee65043 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-break.expect.md
@@ -67,11 +67,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
  */
 function ComponentA(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
-  const c_2 = $[2] !== props.d;
   let a_DEBUG;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.a || $[1] !== props.b || $[2] !== props.d) {
     a_DEBUG = [];
     a_DEBUG.push(props.a);
     if (props.b) {
@@ -94,9 +91,8 @@ function ComponentA(props) {
  */
 function ComponentB(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let a;
-  if (c_0) {
+  if ($[0] !== props) {
     a = [];
     a.push(props.a);
     if (props.b) {
@@ -117,9 +113,8 @@ function ComponentB(props) {
  */
 function ComponentC(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let a;
-  if (c_0) {
+  if ($[0] !== props) {
     a = [];
     a.push(props.a);
     if (props.b) {
@@ -141,9 +136,8 @@ function ComponentC(props) {
  */
 function ComponentD(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let a;
-  if (c_0) {
+  if ($[0] !== props) {
     a = [];
     a.push(props.a);
     if (props.b) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-on-mutable.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-on-mutable.expect.md
index 86fa304bbb..4ab5599071 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-on-mutable.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/conditional-on-mutable.expect.md
@@ -37,10 +37,9 @@ function mayMutate() {}
 import { unstable_useMemoCache as useMemoCache } from "react";
 function ComponentA(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props;
   let a;
   let b;
-  if (c_0) {
+  if ($[0] !== props) {
     a = [];
     b = [];
     if (b) {
@@ -56,10 +55,8 @@ function ComponentA(props) {
     a = $[1];
     b = $[2];
   }
-  const c_3 = $[3] !== a;
-  const c_4 = $[4] !== b;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== a || $[4] !== b) {
     t0 = <Foo a={a} b={b} />;
     $[3] = a;
     $[4] = b;
@@ -72,10 +69,9 @@ function ComponentA(props) {
 
 function ComponentB(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props;
   let a;
   let b;
-  if (c_0) {
+  if ($[0] !== props) {
     a = [];
     b = [];
     if (mayMutate(b)) {
@@ -91,10 +87,8 @@ function ComponentB(props) {
     a = $[1];
     b = $[2];
   }
-  const c_3 = $[3] !== a;
-  const c_4 = $[4] !== b;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== a || $[4] !== b) {
     t0 = <Foo a={a} b={b} />;
     $[3] = a;
     $[4] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/console-readonly.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/console-readonly.expect.md
index 0c1286b72b..66900d06ae 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/console-readonly.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/console-readonly.expect.md
@@ -32,9 +32,8 @@ import { shallowCopy } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = shallowCopy(props);
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-computed.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-computed.expect.md
index 59a22741f5..8f0088e0ca 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-computed.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-computed.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.foo;
   let x;
-  if (c_0) {
+  if ($[0] !== props.foo) {
     x = {};
     x.foo = x.foo + x.bar;
     x.foo(props.foo);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-propagate-global-phis.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-propagate-global-phis.expect.md
index b42871a3b4..7aafdc8064 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-propagate-global-phis.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/constant-propagate-global-phis.expect.md
@@ -39,9 +39,8 @@ function Test() {
   const $ = useMemoCache(2);
   const { tab } = useFoo();
   const currentTab = tab === CONST_STRING0 ? CONST_STRING0 : CONST_STRING1;
-  const c_0 = $[0] !== currentTab;
   let t0;
-  if (c_0) {
+  if ($[0] !== currentTab) {
     t0 = <Text value={currentTab} />;
     $[0] = currentTab;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/controlled-input.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/controlled-input.expect.md
index 5ca23b5f49..285ab4acc6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/controlled-input.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/controlled-input.expect.md
@@ -32,10 +32,8 @@ function component() {
     t0 = $[0];
   }
   const handler = t0;
-  const c_1 = $[1] !== handler;
-  const c_2 = $[2] !== x;
   let t1;
-  if (c_1 || c_2) {
+  if ($[1] !== handler || $[2] !== x) {
     t1 = <input onChange={handler} value={x} />;
     $[1] = handler;
     $[2] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/debugger-memoized.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/debugger-memoized.expect.md
index b76c578c44..be49b921e3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/debugger-memoized.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/debugger-memoized.expect.md
@@ -23,9 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.value;
   let x;
-  if (c_0) {
+  if ($[0] !== props.value) {
     x = [];
     debugger;
 
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-array-with-unary.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-array-with-unary.expect.md
index 3db2d45363..13ef0db583 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-array-with-unary.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-array-with-unary.expect.md
@@ -19,9 +19,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t0) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? [-1, 1] : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-calls-global-function.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-calls-global-function.expect.md
index 7b3d629fa8..b4d1a2fdcc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-calls-global-function.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-calls-global-function.expect.md
@@ -23,9 +23,8 @@ import { identity } from "shared-runtime";
 
 function Component(t0) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? identity([() => {}, true, 42, "hello"]) : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-empty-callback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-empty-callback.expect.md
index 60c012bed9..e77eb1b181 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-empty-callback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-empty-callback.expect.md
@@ -19,9 +19,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t0) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? () => {} : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-reorderable-callback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-reorderable-callback.expect.md
index 94705daf04..fce18ff379 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-reorderable-callback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/default-param-with-reorderable-callback.expect.md
@@ -19,9 +19,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t0) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? () => [-1, true, 42, "hello"] : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-computed-property.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-computed-property.expect.md
index 40aec57088..e0adcfeb08 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-computed-property.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-computed-property.expect.md
@@ -23,10 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     x = { a: props.a, b: props.b };
     delete x["b"];
     $[0] = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-property.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-property.expect.md
index b6c46c1652..b44af9cf1f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-property.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/delete-property.expect.md
@@ -22,10 +22,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     x = { a: props.a, b: props.b };
     delete x.b;
     $[0] = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies-outputs.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies-outputs.expect.md
index a1a77ad17f..2095376198 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies-outputs.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies-outputs.expect.md
@@ -31,9 +31,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = [];
     x.push(a);
     $[0] = a;
@@ -41,10 +40,8 @@ function foo(a, b) {
   } else {
     x = $[1];
   }
-  const c_2 = $[2] !== x;
-  const c_3 = $[3] !== b;
   let y;
-  if (c_2 || c_3) {
+  if ($[2] !== x || $[3] !== b) {
     y = [];
     if (x.length) {
       y.push(x);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies.expect.md
index 506ca267a7..796e4db1df 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/dependencies.expect.md
@@ -34,10 +34,8 @@ function foo(x, y, z) {
   const $ = useMemoCache(3);
   const items = [z];
   items.push(x);
-  const c_0 = $[0] !== x;
-  const c_1 = $[1] !== y;
   let items2;
-  if (c_0 || c_1) {
+  if ($[0] !== x || $[1] !== y) {
     items2 = [];
     if (x) {
       items2.push(y);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-capture-global.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-capture-global.expect.md
index 133bfc870e..38fa64cfa1 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-capture-global.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-capture-global.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 let someGlobal = {};
 function component(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a, someGlobal };
     $[0] = a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-default-array-with-unary.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-default-array-with-unary.expect.md
index cabb14eea1..cf0ab877d5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-default-array-with-unary.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructure-default-array-with-unary.expect.md
@@ -21,9 +21,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const [t0] = props.value;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? [-1, 1] : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-array-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-array-default.expect.md
index 0c993195d4..7fb1cc2d79 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-array-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-array-default.expect.md
@@ -22,9 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const [t0] = props.y;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? ["default"] : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment-array-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment-array-default.expect.md
index d50b4a4911..4c7a5908a6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment-array-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment-array-default.expect.md
@@ -29,9 +29,8 @@ function Component(props) {
   let x = undefined;
   if (props.cond) {
     const [t0] = props.y;
-    const c_0 = $[0] !== t0;
     let t1;
-    if (c_0) {
+    if ($[0] !== t0) {
       t1 = t0 === undefined ? ["default"] : t0;
       $[0] = t0;
       $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment.expect.md
index 0f996adb2c..f2c09bb122 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-assignment.expect.md
@@ -44,12 +44,8 @@ function foo(a, b, c) {
   const { m: t58 } = t55;
   const [t60] = t58;
   const [n] = t60;
-  const c_0 = $[0] !== d;
-  const c_1 = $[1] !== g;
-  const c_2 = $[2] !== n;
-  const c_3 = $[3] !== o;
   let t0;
-  if (c_0 || c_1 || c_2 || c_3) {
+  if ($[0] !== d || $[1] !== g || $[2] !== n || $[3] !== o) {
     t0 = { d, g, n, o };
     $[0] = d;
     $[1] = g;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
index f12061aa0a..f883f06bce 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-and-local-variables-with-default.expect.md
@@ -58,17 +58,15 @@ function useFragment(_arg1, _arg2) {
 function Component(props) {
   const $ = useMemoCache(16);
   const post = useFragment(graphql`...`, props.post);
-  const c_0 = $[0] !== post;
   let media;
   let allUrls;
   let onClick;
-  if (c_0) {
+  if ($[0] !== post) {
     allUrls = [];
 
     const { media: t0, comments: t2, urls: t4 } = post;
-    const c_4 = $[4] !== t0;
     let t1;
-    if (c_4) {
+    if ($[4] !== t0) {
       t1 = t0 === undefined ? null : t0;
       $[4] = t0;
       $[5] = t1;
@@ -76,9 +74,8 @@ function Component(props) {
       t1 = $[5];
     }
     media = t1;
-    const c_6 = $[6] !== t2;
     let t3;
-    if (c_6) {
+    if ($[6] !== t2) {
       t3 = t2 === undefined ? [] : t2;
       $[6] = t2;
       $[7] = t3;
@@ -86,9 +83,8 @@ function Component(props) {
       t3 = $[7];
     }
     const comments = t3;
-    const c_8 = $[8] !== t4;
     let t5;
-    if (c_8) {
+    if ($[8] !== t4) {
       t5 = t4 === undefined ? [] : t4;
       $[8] = t4;
       $[9] = t5;
@@ -96,9 +92,8 @@ function Component(props) {
       t5 = $[9];
     }
     const urls = t5;
-    const c_10 = $[10] !== comments.length;
     let t6;
-    if (c_10) {
+    if ($[10] !== comments.length) {
       t6 = (e) => {
         if (!comments.length) {
           return;
@@ -123,11 +118,8 @@ function Component(props) {
     allUrls = $[2];
     onClick = $[3];
   }
-  const c_12 = $[12] !== media;
-  const c_13 = $[13] !== allUrls;
-  const c_14 = $[14] !== onClick;
   let t7;
-  if (c_12 || c_13 || c_14) {
+  if ($[12] !== media || $[13] !== allUrls || $[14] !== onClick) {
     t7 = <Stringify media={media} allUrls={allUrls} onClick={onClick} />;
     $[12] = media;
     $[13] = allUrls;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
index 9d606ddc5b..83f9bb28a8 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-mixed-scope-declarations-and-locals.expect.md
@@ -32,17 +32,15 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(8);
   const post = useFragment(graphql`...`, props.post);
-  const c_0 = $[0] !== post;
   let media;
   let onClick;
-  if (c_0) {
+  if ($[0] !== post) {
     const allUrls = [];
 
     const { media: t83, comments, urls } = post;
     media = t83;
-    const c_3 = $[3] !== comments.length;
     let t0;
-    if (c_3) {
+    if ($[3] !== comments.length) {
       t0 = (e) => {
         if (!comments.length) {
           return;
@@ -65,10 +63,8 @@ function Component(props) {
     media = $[1];
     onClick = $[2];
   }
-  const c_5 = $[5] !== media;
-  const c_6 = $[6] !== onClick;
   let t1;
-  if (c_5 || c_6) {
+  if ($[5] !== media || $[6] !== onClick) {
     t1 = <Media media={media} onClick={onClick} />;
     $[5] = media;
     $[6] = onClick;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-default.expect.md
index d78ade2d0e..5d9156f3be 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-default.expect.md
@@ -22,9 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const { x: t0 } = props.y;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? { y: "default" } : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-pattern-within-rest.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-pattern-within-rest.expect.md
index 441af29219..091a674e0e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-pattern-within-rest.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-object-pattern-within-rest.expect.md
@@ -20,10 +20,9 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props.value;
   let t0;
   let y;
-  if (c_0) {
+  if ($[0] !== props.value) {
     [y, ...t0] = props.value;
     $[0] = props.value;
     $[1] = t0;
@@ -33,10 +32,8 @@ function Component(props) {
     y = $[2];
   }
   const { z } = t0;
-  const c_3 = $[3] !== y;
-  const c_4 = $[4] !== z;
   let t1;
-  if (c_3 || c_4) {
+  if ($[3] !== y || $[4] !== z) {
     t1 = [y, z];
     $[3] = y;
     $[4] = z;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-property-inference.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-property-inference.expect.md
index 57536d03a9..0ec8987690 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-property-inference.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-property-inference.expect.md
@@ -18,9 +18,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.value;
   let x;
-  if (c_0) {
+  if ($[0] !== props.value) {
     x = [];
     x.push(props.value);
     $[0] = props.value;
@@ -30,10 +29,8 @@ function Component(props) {
   }
   const { length: y } = x;
   foo(y);
-  const c_2 = $[2] !== x;
-  const c_3 = $[3] !== y;
   let t0;
-  if (c_2 || c_3) {
+  if ($[2] !== x || $[3] !== y) {
     t0 = [x, y];
     $[2] = x;
     $[3] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-with-typecast-as-default-value.flow.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-with-typecast-as-default-value.flow.expect.md
index fe1f14ef73..1d929ee43f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-with-typecast-as-default-value.flow.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring-with-typecast-as-default-value.flow.expect.md
@@ -21,9 +21,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const [t0] = props.y;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? ([]: Array<number>) : t0;
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring.expect.md
index 334017e415..c716448ac0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/destructuring.expect.md
@@ -36,11 +36,10 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(18);
-  const c_0 = $[0] !== a;
   let t0;
   let d;
   let h;
-  if (c_0) {
+  if ($[0] !== a) {
     [d, t0, ...h] = a;
     $[0] = a;
     $[1] = t0;
@@ -52,10 +51,9 @@ function foo(a, b, c) {
     h = $[3];
   }
   const [t1] = t0;
-  const c_4 = $[4] !== t1;
   let t2;
   let g;
-  if (c_4) {
+  if ($[4] !== t1) {
     ({ e: t2, ...g } = t1);
     $[4] = t1;
     $[5] = t2;
@@ -67,10 +65,9 @@ function foo(a, b, c) {
   const { f } = t2;
   const { l: t51, p } = b;
   const { m: t3 } = t51;
-  const c_7 = $[7] !== t3;
   let t4;
   let o;
-  if (c_7) {
+  if ($[7] !== t3) {
     [t4, ...o] = t3;
     $[7] = t3;
     $[8] = t4;
@@ -80,15 +77,16 @@ function foo(a, b, c) {
     o = $[9];
   }
   const [n] = t4;
-  const c_10 = $[10] !== d;
-  const c_11 = $[11] !== f;
-  const c_12 = $[12] !== g;
-  const c_13 = $[13] !== h;
-  const c_14 = $[14] !== n;
-  const c_15 = $[15] !== o;
-  const c_16 = $[16] !== p;
   let t5;
-  if (c_10 || c_11 || c_12 || c_13 || c_14 || c_15 || c_16) {
+  if (
+    $[10] !== d ||
+    $[11] !== f ||
+    $[12] !== g ||
+    $[13] !== h ||
+    $[14] !== n ||
+    $[15] !== o ||
+    $[16] !== p
+  ) {
     t5 = [d, f, g, h, n, o, p];
     $[10] = d;
     $[11] = f;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-compound-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-compound-test.expect.md
index 7019e5c914..11fa43db32 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-compound-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-compound-test.expect.md
@@ -26,9 +26,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let ret;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = [1, 2, 3];
     ret = [];
     do {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-conditional-break.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-conditional-break.expect.md
index 857d4dbdbe..680bb4f9af 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-conditional-break.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/do-while-conditional-break.expect.md
@@ -21,9 +21,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [0, 1, 2, 3];
     do {
       if (x === 0) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usecallback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usecallback.expect.md
index e0552b2d8a..c84416138c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usecallback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usecallback.expect.md
@@ -26,9 +26,8 @@ import * as React from "react";
 
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.value;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.value) {
     t0 = () => {
       console.log(props.value);
     };
@@ -38,9 +37,8 @@ function Component(props) {
     t0 = $[1];
   }
   const onClick = t0;
-  const c_2 = $[2] !== onClick;
   let t1;
-  if (c_2) {
+  if ($[2] !== onClick) {
     t1 = <div onClick={onClick} />;
     $[2] = onClick;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
index f181418a32..63622dd87d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/drop-methodcall-usememo.expect.md
@@ -29,9 +29,8 @@ import * as React from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   let t42;
-  const c_0 = $[0] !== props.value;
   let x;
-  if (c_0) {
+  if ($[0] !== props.value) {
     x = [];
     x.push(props.value);
     $[0] = props.value;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
index e4a62cccf6..b2167c3b55 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-destructured-rest-element.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
   let b;
-  if (c_0) {
+  if ($[0] !== props.a) {
     const { a, ...t29 } = props.a;
     b = t29;
     $[0] = props.a;
@@ -34,9 +33,8 @@ function Component(props) {
   } else {
     b = $[1];
   }
-  const c_2 = $[2] !== props.c;
   let d;
-  if (c_2) {
+  if ($[2] !== props.c) {
     const [c, ...t30] = props.c;
     d = t30;
     $[2] = props.c;
@@ -44,10 +42,8 @@ function Component(props) {
   } else {
     d = $[3];
   }
-  const c_4 = $[4] !== b;
-  const c_5 = $[5] !== d;
   let t0;
-  if (c_4 || c_5) {
+  if ($[4] !== b || $[5] !== d) {
     t0 = <div b={b} d={d} />;
     $[4] = b;
     $[5] = d;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-jsx-child.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-jsx-child.expect.md
index 13f83fdc1b..910c184cdd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-jsx-child.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-jsx-child.expect.md
@@ -28,17 +28,12 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [];
     if (a) {
-      const c_4 = $[4] !== b;
-      const c_5 = $[5] !== c;
       let y;
-      if (c_4 || c_5) {
+      if ($[4] !== b || $[5] !== c) {
         y = [];
         if (b) {
           y.push(c);
@@ -49,9 +44,8 @@ function foo(a, b, c) {
       } else {
         y = $[6];
       }
-      const c_7 = $[7] !== y;
       let t0;
-      if (c_7) {
+      if ($[7] !== y) {
         t0 = <div>{y}</div>;
         $[7] = y;
         $[8] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-logical.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-logical.expect.md
index 54e17127f5..38ddc62798 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-logical.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-logical.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(10);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = [props.a];
     $[0] = props.a;
     $[1] = t0;
@@ -35,9 +34,8 @@ function Component(props) {
     t0 = $[1];
   }
   const a = t0;
-  const c_2 = $[2] !== props.b;
   let t1;
-  if (c_2) {
+  if ($[2] !== props.b) {
     t1 = [props.b];
     $[2] = props.b;
     $[3] = t1;
@@ -45,9 +43,8 @@ function Component(props) {
     t1 = $[3];
   }
   const b = t1;
-  const c_4 = $[4] !== props.c;
   let t2;
-  if (c_4) {
+  if ($[4] !== props.c) {
     t2 = [props.c];
     $[4] = props.c;
     $[5] = t2;
@@ -55,11 +52,8 @@ function Component(props) {
     t2 = $[5];
   }
   const c = t2;
-  const c_6 = $[6] !== a;
-  const c_7 = $[7] !== b;
-  const c_8 = $[8] !== c;
   let t3;
-  if (c_6 || c_7 || c_8) {
+  if ($[6] !== a || $[7] !== b || $[8] !== c) {
     t3 = (a && b) || c;
     $[6] = a;
     $[7] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-dependency.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-dependency.expect.md
index 709717619f..51f533a6b7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-dependency.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-dependency.expect.md
@@ -32,9 +32,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = [props.a];
     $[0] = props.a;
     $[1] = t0;
@@ -42,10 +41,8 @@ function Component(props) {
     t0 = $[1];
   }
   const a = t0;
-  const c_2 = $[2] !== a;
-  const c_3 = $[3] !== props.b;
   let b;
-  if (c_2 || c_3) {
+  if ($[2] !== a || $[3] !== props.b) {
     b = [];
     const c = {};
     c.a = a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-nested-dependency.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-nested-dependency.expect.md
index 8f46c822a0..f2a350262d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-nested-dependency.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-allocating-nested-dependency.expect.md
@@ -41,9 +41,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = [props.a];
     $[0] = props.a;
     $[1] = t0;
@@ -51,9 +50,8 @@ function Component(props) {
     t0 = $[1];
   }
   const a = t0;
-  const c_2 = $[2] !== a;
   let t1;
-  if (c_2) {
+  if ($[2] !== a) {
     t1 = [a];
     $[2] = a;
     $[3] = t1;
@@ -61,10 +59,8 @@ function Component(props) {
     t1 = $[3];
   }
   const b = t1;
-  const c_4 = $[4] !== b;
-  const c_5 = $[5] !== props.b;
   let c;
-  if (c_4 || c_5) {
+  if ($[4] !== b || $[5] !== props.b) {
     c = [];
     const d = {};
     d.b = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-primitive-dependency.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-primitive-dependency.expect.md
index f1796beaf3..94cad821c2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-primitive-dependency.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/escape-analysis-non-escaping-interleaved-primitive-dependency.expect.md
@@ -36,10 +36,8 @@ function Component(props) {
   const $ = useMemoCache(3);
 
   const a = props.a + props.b;
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== props.c;
   let b;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== props.c) {
     b = [];
     const c = {};
     c.a = a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/extend-scopes-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/extend-scopes-if.expect.md
index 479836af1b..a76139b660 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/extend-scopes-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/extend-scopes-if.expect.md
@@ -31,11 +31,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [];
     if (a) {
       if (b) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call-complex-param-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call-complex-param-value.expect.md
index 8e3d82f3d8..a48e57083e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call-complex-param-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call-complex-param-value.expect.md
@@ -22,9 +22,8 @@ import fbt from "fbt";
 
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.name;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.name) {
     t0 = fbt._(
       "Hello, {(key) name}!",
       [fbt._param("(key) name", capitalize(props.name))],
@@ -36,9 +35,8 @@ function Component(props) {
     t0 = $[1];
   }
   const text = t0;
-  const c_2 = $[2] !== text;
   let t1;
-  if (c_2) {
+  if ($[2] !== text) {
     t1 = <div>{text}</div>;
     $[2] = text;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call.expect.md
index 2a431b6a61..daa927ea24 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-call.expect.md
@@ -22,9 +22,8 @@ import fbt from "fbt";
 
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.count;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.count) {
     t0 = fbt._(
       "{(key) count} items",
       [fbt._param("(key) count", props.count)],
@@ -36,9 +35,8 @@ function Component(props) {
     t0 = $[1];
   }
   const text = t0;
-  const c_2 = $[2] !== text;
   let t1;
-  if (c_2) {
+  if ($[2] !== text) {
     t1 = <div>{text}</div>;
     $[2] = text;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params-complex-param-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params-complex-param-value.expect.md
index 43e9aa7f7a..47e906e55a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params-complex-param-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params-complex-param-value.expect.md
@@ -22,9 +22,8 @@ import fbt from "fbt";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.name;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.name) {
     t0 = fbt._(
       "Hello {user name}",
       [fbt._param("user name", capitalize(props.name))],
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params.expect.md
index 74b3c074c1..91fd02300d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-params.expect.md
@@ -28,9 +28,8 @@ import fbt from "fbt";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.name;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.name) {
     t0 = fbt._("Hello {user name}", [fbt._param("user name", props.name)], {
       hk: "2zEDKF",
     });
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-preserve-jsxtext.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-preserve-jsxtext.expect.md
index 1bb46e5cbc..3acc469508 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-preserve-jsxtext.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-preserve-jsxtext.expect.md
@@ -27,9 +27,8 @@ import fbt from "fbt";
 
 function Foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.value;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.value) {
     t0 = fbt._(
       { "0": "hello {value},", "1": "goodbye {value}," },
       [
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-template-string-same-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-template-string-same-scope.expect.md
index 45ee3384b6..4e4a7c2225 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-template-string-same-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbt-template-string-same-scope.expect.md
@@ -34,9 +34,8 @@ export function Component(props) {
   if (props.items) {
     count = props.items.length;
   }
-  const c_0 = $[0] !== count;
   let t0;
-  if (c_0) {
+  if ($[0] !== count) {
     t0 = fbt._("for {count} experiences", [fbt._param("count", count)], {
       hk: "nmYpm",
     });
@@ -45,9 +44,8 @@ export function Component(props) {
   } else {
     t0 = $[1];
   }
-  const c_2 = $[2] !== t0;
   let t1;
-  if (c_2) {
+  if ($[2] !== t0) {
     t1 = <View>{t0}</View>;
     $[2] = t0;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-element-content.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-element-content.expect.md
index 64db38edaf..83ffc40247 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-element-content.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-element-content.expect.md
@@ -31,11 +31,8 @@ import fbt from "fbt";
 function Component(t29) {
   const $ = useMemoCache(4);
   const { name, data, icon } = t29;
-  const c_0 = $[0] !== name;
-  const c_1 = $[1] !== icon;
-  const c_2 = $[2] !== data;
   let t0;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== name || $[1] !== icon || $[2] !== data) {
     t0 = (
       <Text type="body4">
         {fbt._(
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-fragment-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-fragment-value.expect.md
index 38c76f4e25..11086737b7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-fragment-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/fbtparam-with-jsx-fragment-value.expect.md
@@ -28,9 +28,8 @@ import { identity } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.text;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.text) {
     t0 = (
       <Foo
         value={fbt._(
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-break.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-break.expect.md
index 3de52fd440..93b7f7caff 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-break.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-break.expect.md
@@ -28,9 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.value;
   let x;
-  if (c_0) {
+  if ($[0] !== props.value) {
     const object = { ...props.value };
     for (const y in object) {
       if (y === "break") {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-continue.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-continue.expect.md
index 32524eeccb..647ba9b6d3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-continue.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement-continue.expect.md
@@ -29,9 +29,8 @@ function Component(props) {
   const $ = useMemoCache(3);
   let x;
   if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    const c_1 = $[1] !== props.value;
     let t0;
-    if (c_1) {
+    if ($[1] !== props.value) {
       t0 = { ...props.value };
       $[1] = props.value;
       $[2] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement.expect.md
index 7c53357010..b0976effa1 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/for-in-statement.expect.md
@@ -23,9 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props;
   let items;
-  if (c_0) {
+  if ($[0] !== props) {
     items = [];
     for (const key in props) {
       items.push(<div key={key}>{key}</div>);
@@ -35,9 +34,8 @@ function Component(props) {
   } else {
     items = $[1];
   }
-  const c_2 = $[2] !== items;
   let t0;
-  if (c_2) {
+  if ($[2] !== items) {
     t0 = <div>{items}</div>;
     $[2] = items;
     $[3] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-declaration-simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-declaration-simple.expect.md
index 257f42fd46..474cf9ace7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-declaration-simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-declaration-simple.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
   let t;
-  if (c_0) {
+  if ($[0] !== a) {
     t = { a };
     let t0;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-maybe-mutates-hook-return-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-maybe-mutates-hook-return-value.expect.md
index f37b848b45..376ce0c157 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-maybe-mutates-hook-return-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-maybe-mutates-hook-return-value.expect.md
@@ -24,9 +24,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
   const id = useSelectedEntitytId();
-  const c_0 = $[0] !== id;
   let t0;
-  if (c_0) {
+  if ($[0] !== id) {
     t0 = () => {
       log(id);
     };
@@ -36,9 +35,8 @@ function Component(props) {
     t0 = $[1];
   }
   const onLoad = t0;
-  const c_2 = $[2] !== onLoad;
   let t1;
-  if (c_2) {
+  if ($[2] !== onLoad) {
     t1 = <Foo onLoad={onLoad} />;
     $[2] = onLoad;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-with-store-to-parameter.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-with-store-to-parameter.expect.md
index 8d1c48f2c1..fe47a6d088 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-with-store-to-parameter.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-expression-with-store-to-parameter.expect.md
@@ -31,9 +31,8 @@ function Component(props) {
     t0 = $[0];
   }
   const mutate = t0;
-  const c_1 = $[1] !== props;
   let x;
-  if (c_1) {
+  if ($[1] !== props) {
     x = makeObject(props);
     mutate(x);
     $[1] = props;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-param-assignment-pattern.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-param-assignment-pattern.expect.md
index 9df35ddf40..a1a5de3220 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-param-assignment-pattern.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/function-param-assignment-pattern.expect.md
@@ -21,9 +21,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t23, t0) {
   const $ = useMemoCache(5);
   const x = t23 === undefined ? "default" : t23;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = t0 === undefined ? [{}] : t0;
     $[0] = t0;
     $[1] = t1;
@@ -31,10 +30,8 @@ function Component(t23, t0) {
     t1 = $[1];
   }
   const y = t1;
-  const c_2 = $[2] !== x;
-  const c_3 = $[3] !== y;
   let t2;
-  if (c_2 || c_3) {
+  if ($[2] !== x || $[3] !== y) {
     t2 = [x, y];
     $[2] = x;
     $[3] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-default-function.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-default-function.expect.md
index 7181c74896..d6a9af708d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-default-function.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-default-function.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating @compi
 export default isForgetEnabled_Fixtures()
   ? function Bar(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <div>{props.bar}</div>;
         $[0] = props.bar;
         $[1] = t0;
@@ -49,9 +48,8 @@ function NoForget(props) {
 const Foo = isForgetEnabled_Fixtures()
   ? function Foo(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <Foo>{props.bar}</Foo>;
         $[0] = props.bar;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function-and-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function-and-default.expect.md
index 25cebf9abc..afe7fbdd1d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function-and-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function-and-default.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating @compi
 export default isForgetEnabled_Fixtures()
   ? function Bar(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <div>{props.bar}</div>;
         $[0] = props.bar;
         $[1] = t0;
@@ -50,9 +49,8 @@ function NoForget(props) {
 export const Foo = isForgetEnabled_Fixtures()
   ? function Foo(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <Foo>{props.bar}</Foo>;
         $[0] = props.bar;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function.expect.md
index 8c0b497327..c800dcd897 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test-export-function.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating @compi
 export const Bar = isForgetEnabled_Fixtures()
   ? function Bar(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <div>{props.bar}</div>;
         $[0] = props.bar;
         $[1] = t0;
@@ -50,9 +49,8 @@ export function NoForget(props) {
 export const Foo = isForgetEnabled_Fixtures()
   ? function Foo(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <Foo>{props.bar}</Foo>;
         $[0] = props.bar;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test.expect.md
index 7a43fda3c3..11c1d920fd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/gating-test.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating @compi
 const Bar = isForgetEnabled_Fixtures()
   ? function Bar(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <div>{props.bar}</div>;
         $[0] = props.bar;
         $[1] = t0;
@@ -49,9 +48,8 @@ function NoForget(props) {
 const Foo = isForgetEnabled_Fixtures()
   ? function Foo(props) {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== props.bar;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.bar) {
         t0 = <Foo>{props.bar}</Foo>;
         $[0] = props.bar;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hoisting-nested-const-declaration-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hoisting-nested-const-declaration-2.expect.md
index a386642ab4..63918c2c61 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hoisting-nested-const-declaration-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hoisting-nested-const-declaration-2.expect.md
@@ -28,9 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function hoisting(cond) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== cond;
   let items;
-  if (c_0) {
+  if ($[0] !== cond) {
     items = [];
     if (cond) {
       const foo = () => {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/holey-array-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/holey-array-expr.expect.md
index 754dea459f..a4512548b2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/holey-array-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/holey-array-expr.expect.md
@@ -25,9 +25,8 @@ import { CONST_STRING0 } from "shared-runtime";
 
 function t(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = [, CONST_STRING0, props];
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-call.expect.md
index b37d1d8c4b..2885090a6c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-call.expect.md
@@ -38,9 +38,8 @@ function Component(props) {
   const x = t0;
   const y = useFreeze(x);
   foo(y, x);
-  const c_1 = $[1] !== y;
   let t1;
-  if (c_1) {
+  if ($[1] !== y) {
     t1 = (
       <Component>
         {x}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-noAlias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-noAlias.expect.md
index dc025f44e2..239cf8b6da 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-noAlias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/hook-noAlias.expect.md
@@ -32,9 +32,8 @@ import { useNoAlias } from "shared-runtime";
 
 function Component(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = { a: props.a };
     $[0] = props.a;
     $[1] = t0;
@@ -49,10 +48,8 @@ function Component(props) {
     },
     [props.a]
   );
-  const c_2 = $[2] !== x;
-  const c_3 = $[3] !== item;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== x || $[3] !== item) {
     t1 = [x, item];
     $[2] = x;
     $[3] = item;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/immutable-hooks.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/immutable-hooks.expect.md
index a4f065bb82..c926a98c32 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/immutable-hooks.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/immutable-hooks.expect.md
@@ -32,9 +32,8 @@ function Component(props) {
   const y = useFoo(x);
 
   bar(x, y);
-  const c_1 = $[1] !== y;
   let t1;
-  if (c_1) {
+  if ($[1] !== y) {
     t1 = [x, y];
     $[1] = y;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inadvertent-mutability-readonly-lambda.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inadvertent-mutability-readonly-lambda.expect.md
index 22afe82a58..aeb4540a79 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inadvertent-mutability-readonly-lambda.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inadvertent-mutability-readonly-lambda.expect.md
@@ -35,9 +35,8 @@ function Component(props) {
   const onChange = t0;
 
   useOtherHook();
-  const c_1 = $[1] !== onChange;
   let x;
-  if (c_1) {
+  if ($[1] !== onChange) {
     x = {};
     foo(x, onChange);
     $[1] = onChange;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent-across-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent-across-if.expect.md
index 9e78cf11ca..27168b3915 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent-across-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent-across-if.expect.md
@@ -58,12 +58,9 @@ function Foo() {}
  */
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
-  const c_2 = $[2] !== props.c;
   let a;
   let b;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.a || $[1] !== props.b || $[2] !== props.c) {
     a = compute(props.a);
     b = compute(props.b);
     if (props.c) {
@@ -79,10 +76,8 @@ function Component(props) {
     a = $[3];
     b = $[4];
   }
-  const c_5 = $[5] !== a;
-  const c_6 = $[6] !== b;
   let t0;
-  if (c_5 || c_6) {
+  if ($[5] !== a || $[6] !== b) {
     t0 = <Foo a={a} b={b} />;
     $[5] = a;
     $[6] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent.expect.md
index 44f64ad0b5..29b9ac803a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independent.expect.md
@@ -40,9 +40,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
  */
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = compute(props.a);
     $[0] = props.a;
     $[1] = t0;
@@ -50,9 +49,8 @@ function Component(props) {
     t0 = $[1];
   }
   const a = t0;
-  const c_2 = $[2] !== props.b;
   let t1;
-  if (c_2) {
+  if ($[2] !== props.b) {
     t1 = compute(props.b);
     $[2] = props.b;
     $[3] = t1;
@@ -60,10 +58,8 @@ function Component(props) {
     t1 = $[3];
   }
   const b = t1;
-  const c_4 = $[4] !== a;
-  const c_5 = $[5] !== b;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== a || $[5] !== b) {
     t2 = <Foo a={a} b={b} />;
     $[4] = a;
     $[5] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independently-memoize-object-property.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independently-memoize-object-property.expect.md
index 3569a34c0e..5f5847f38d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independently-memoize-object-property.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/independently-memoize-object-property.expect.md
@@ -24,16 +24,11 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = { a };
-    const c_4 = $[4] !== b;
-    const c_5 = $[5] !== c;
     let t0;
-    if (c_4 || c_5) {
+    if ($[4] !== b || $[5] !== c) {
       t0 = [b, c];
       $[4] = b;
       $[5] = c;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-component-with-hook-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-component-with-hook-call.expect.md
index 152263f59c..08ab22f8eb 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-component-with-hook-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-component-with-hook-call.expect.md
@@ -17,9 +17,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @compilationMo
 function Component(props) {
   const $ = useMemoCache(2);
   const [state] = useState(null);
-  const c_0 = $[0] !== state;
   let t0;
-  if (c_0) {
+  if ($[0] !== state) {
     t0 = [state];
     $[0] = state;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-hook-with-hook-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-hook-with-hook-call.expect.md
index 24e31a716a..997b99492c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-hook-with-hook-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-functions-hook-with-hook-call.expect.md
@@ -17,9 +17,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @compilationMo
 function useStateValue(props) {
   const $ = useMemoCache(2);
   const [state] = useState(null);
-  const c_0 = $[0] !== state;
   let t0;
-  if (c_0) {
+  if ($[0] !== state) {
     t0 = [state];
     $[0] = state;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-global-object.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-global-object.expect.md
index 3c750df8d8..e73ad7b6ad 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-global-object.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/infer-global-object.expect.md
@@ -36,9 +36,8 @@ import { identity, sum } from "shared-runtime";
 // global object.
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.b;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.b) {
     t0 = identity(props.b);
     $[0] = props.b;
     $[1] = t0;
@@ -51,9 +50,8 @@ function Component(props) {
   const primitiveVal3 = globalThis.globalThis.NaN;
 
   sum(primitiveVal1, Infinity, primitiveVal3);
-  const c_2 = $[2] !== primitiveVal1;
   let t1;
-  if (c_2) {
+  if ($[2] !== primitiveVal1) {
     t1 = { primitiveVal1, primitiveVal2: Infinity, primitiveVal3 };
     $[2] = primitiveVal1;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
index c189210d5b..97c6f6bae5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inner-memo-value-not-promoted-to-outer-scope-dynamic.expect.md
@@ -27,12 +27,11 @@ function Component(props) {
   const $ = useMemoCache(15);
   const item = useFragment(FRAGMENT, props.item);
   useFreeze(item);
-  const c_0 = $[0] !== item;
   let t1;
   let T2;
   let t0;
   let T3;
-  if (c_0) {
+  if ($[0] !== item) {
     const count = new MaybeMutable(item);
 
     T3 = View;
@@ -55,20 +54,16 @@ function Component(props) {
     t0 = $[3];
     T3 = $[4];
   }
-  const c_6 = $[6] !== t1;
   let t4;
-  if (c_6) {
+  if ($[6] !== t1) {
     t4 = <span>{t1}</span>;
     $[6] = t1;
     $[7] = t4;
   } else {
     t4 = $[7];
   }
-  const c_8 = $[8] !== T2;
-  const c_9 = $[9] !== t0;
-  const c_10 = $[10] !== t4;
   let t5;
-  if (c_8 || c_9 || c_10) {
+  if ($[8] !== T2 || $[9] !== t0 || $[10] !== t4) {
     t5 = (
       <T2>
         {t0}
@@ -82,10 +77,8 @@ function Component(props) {
   } else {
     t5 = $[11];
   }
-  const c_12 = $[12] !== T3;
-  const c_13 = $[13] !== t5;
   let t6;
-  if (c_12 || c_13) {
+  if ($[12] !== T3 || $[13] !== t5) {
     t6 = <T3>{t5}</T3>;
     $[12] = T3;
     $[13] = t5;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent-across-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent-across-if.expect.md
index 322965a4aa..13db4c01f7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent-across-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent-across-if.expect.md
@@ -47,12 +47,9 @@ function Foo() {}
  */
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
-  const c_2 = $[2] !== props.c;
   let a;
   let b;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.a || $[1] !== props.b || $[2] !== props.c) {
     a = compute(props.a);
     b = compute(props.b);
     if (props.c) {
@@ -67,10 +64,8 @@ function Component(props) {
     a = $[3];
     b = $[4];
   }
-  const c_5 = $[5] !== a;
-  const c_6 = $[6] !== b;
   let t0;
-  if (c_5 || c_6) {
+  if ($[5] !== a || $[6] !== b) {
     t0 = <Foo a={a} b={b} />;
     $[5] = a;
     $[6] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent.expect.md
index 13f481ad4b..c936856579 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/interdependent.expect.md
@@ -39,11 +39,9 @@ import { unstable_useMemoCache as useMemoCache } from "react";
  */
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let a;
   let b;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     a = compute(props.a);
     b = compute(props.b);
     foo(a, b);
@@ -55,10 +53,8 @@ function Component(props) {
     a = $[2];
     b = $[3];
   }
-  const c_4 = $[4] !== a;
-  const c_5 = $[5] !== b;
   let t0;
-  if (c_4 || c_5) {
+  if ($[4] !== a || $[5] !== b) {
     t0 = <Foo a={a} b={b} />;
     $[4] = a;
     $[5] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inverted-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inverted-if.expect.md
index d12da540e2..13fc9aeaee 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inverted-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/inverted-if.expect.md
@@ -28,12 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c, d) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
-  const c_3 = $[3] !== d;
   let y;
-  if (c_0 || c_1 || c_2 || c_3) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c || $[3] !== d) {
     y = [];
     bb1: if (a) {
       if (b) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-element-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-element-value.expect.md
index 53166f4c9d..7267900037 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-element-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-element-value.expect.md
@@ -46,9 +46,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t27) {
   const $ = useMemoCache(2);
   const { items } = t27;
-  const c_0 = $[0] !== items;
   let t0;
-  if (c_0) {
+  if ($[0] !== items) {
     t0 =
       items.length > 0 ? (
         <Foo
@@ -77,9 +76,8 @@ function Foo(t5) {
 function Bar(t6) {
   const $ = useMemoCache(2);
   const { children } = t6;
-  const c_0 = $[0] !== children;
   let t0;
-  if (c_0) {
+  if ($[0] !== children) {
     t0 = <div>{children}</div>;
     $[0] = children;
     $[1] = t0;
@@ -92,9 +90,8 @@ function Bar(t6) {
 function Item(t7) {
   const $ = useMemoCache(2);
   const { item } = t7;
-  const c_0 = $[0] !== item.name;
   let t0;
-  if (c_0) {
+  if ($[0] !== item.name) {
     t0 = <div>{item.name}</div>;
     $[0] = item.name;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-fragment-value.flow.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-fragment-value.flow.expect.md
index e6c996a4f4..9edf316fe5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-fragment-value.flow.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-attribute-with-jsx-fragment-value.flow.expect.md
@@ -33,9 +33,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t26) {
   const $ = useMemoCache(2);
   const { items } = t26;
-  const c_0 = $[0] !== items;
   let t0;
-  if (c_0) {
+  if ($[0] !== items) {
     t0 =
       items.length > 0 ? (
         <Foo
@@ -59,9 +58,8 @@ function Component(t26) {
 function Foo(t7) {
   const $ = useMemoCache(2);
   const { item } = t7;
-  const c_0 = $[0] !== item.name;
   let t0;
-  if (c_0) {
+  if ($[0] !== item.name) {
     t0 = <div>{item.name}</div>;
     $[0] = item.name;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-empty-expression.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-empty-expression.expect.md
index 42a592d35a..a4c2b2ada6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-empty-expression.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-empty-expression.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 export function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = <div>{props.a}</div>;
     $[0] = props.a;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-fragment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-fragment.expect.md
index d2ba9cbde0..2bc34d21d5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-fragment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-fragment.expect.md
@@ -38,9 +38,8 @@ function Foo(props) {
   } else {
     t0 = $[0];
   }
-  const c_1 = $[1] !== props.greeting;
   let t1;
-  if (c_1) {
+  if ($[1] !== props.greeting) {
     t1 = (
       <>
         Hello {props.greeting} {t0}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-namespaced-name.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-namespaced-name.expect.md
index 9f51f232d2..2508db3c59 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-namespaced-name.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-namespaced-name.expect.md
@@ -20,9 +20,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.version;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.version) {
     t0 = <xml:http protocol:version={props.version} />;
     $[0] = props.version;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-reactive-local-variable-member-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-reactive-local-variable-member-expr.expect.md
index 48504a1171..3cda1f4dd3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-reactive-local-variable-member-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-reactive-local-variable-member-expr.expect.md
@@ -31,9 +31,8 @@ function Component(t13) {
   const { something } = t13;
 
   const Foo = something.StaticText1;
-  const c_0 = $[0] !== Foo;
   let t0;
-  if (c_0) {
+  if ($[0] !== Foo) {
     t0 = () => <Foo />;
     $[0] = Foo;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-spread.expect.md
index 27b813adf3..9638d37754 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-spread.expect.md
@@ -18,19 +18,16 @@ function Component(props) {
   const $ = useMemoCache(5);
 
   const t0 = props.cond ? props.foo : props.bar;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = { bar: t0 };
     $[0] = t0;
     $[1] = t1;
   } else {
     t1 = $[1];
   }
-  const c_2 = $[2] !== props;
-  const c_3 = $[3] !== t1;
   let t2;
-  if (c_2 || c_3) {
+  if ($[2] !== props || $[3] !== t1) {
     t2 = <Component {...props} {...t1} />;
     $[2] = props;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
index 02a874861f..9eb47244e6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order-non-global.expect.md
@@ -53,12 +53,10 @@ function maybeMutate(x) {}
 
 function Component(props) {
   const $ = useMemoCache(11);
-  const c_0 = $[0] !== props.component;
-  const c_1 = $[1] !== props.alternateComponent;
   let Tag;
   let T0;
   let t1;
-  if (c_0 || c_1) {
+  if ($[0] !== props.component || $[1] !== props.alternateComponent) {
     const maybeMutable = new MaybeMutable();
     Tag = props.component;
 
@@ -74,20 +72,16 @@ function Component(props) {
     T0 = $[3];
     t1 = $[4];
   }
-  const c_5 = $[5] !== Tag;
   let t2;
-  if (c_5) {
+  if ($[5] !== Tag) {
     t2 = <Tag />;
     $[5] = Tag;
     $[6] = t2;
   } else {
     t2 = $[6];
   }
-  const c_7 = $[7] !== T0;
-  const c_8 = $[8] !== t1;
-  const c_9 = $[9] !== t2;
   let t3;
-  if (c_7 || c_8 || c_9) {
+  if ($[7] !== T0 || $[8] !== t1 || $[9] !== t2) {
     t3 = (
       <T0>
         {t1}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
index 7118915f1b..a2950ccae9 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-tag-evaluation-order.expect.md
@@ -39,9 +39,8 @@ function Component(props) {
   } else {
     t0 = $[0];
   }
-  const c_1 = $[1] !== t1;
   let t2;
-  if (c_1) {
+  if ($[1] !== t1) {
     t2 = (
       <StaticText1>
         {t1}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-ternary-local-variable.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-ternary-local-variable.expect.md
index 9529acd2d1..ec77e60b39 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-ternary-local-variable.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/jsx-ternary-local-variable.expect.md
@@ -26,9 +26,8 @@ import { RenderPropAsChild, StaticText1, StaticText2 } from "shared-runtime";
 function Component(props) {
   const $ = useMemoCache(2);
   const Foo = props.showText1 ? StaticText1 : StaticText2;
-  const c_0 = $[0] !== Foo;
   let t0;
-  if (c_0) {
+  if ($[0] !== Foo) {
     t0 = <RenderPropAsChild items={[() => <Foo key="0" />]} />;
     $[0] = Foo;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-capture-returned-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-capture-returned-alias.expect.md
index b811bbb873..26e11ed2e8 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-capture-returned-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-capture-returned-alias.expect.md
@@ -34,9 +34,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Here, element
 //    them to reads
 function CaptureNotMutate(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props.x;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.x) {
     t0 = foo(props.x);
     $[0] = props.x;
     $[1] = t0;
@@ -44,10 +43,8 @@ function CaptureNotMutate(props) {
     t0 = $[1];
   }
   const idx = t0;
-  const c_2 = $[2] !== props.el;
-  const c_3 = $[3] !== idx;
   let aliasedElement;
-  if (c_2 || c_3) {
+  if ($[2] !== props.el || $[3] !== idx) {
     const element = bar(props.el);
 
     const fn = function () {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-mutated-non-reactive-to-reactive.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-mutated-non-reactive-to-reactive.expect.md
index 5a1eff9101..12053fbfb3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-mutated-non-reactive-to-reactive.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/lambda-mutated-non-reactive-to-reactive.expect.md
@@ -24,9 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function f(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x;
     x = { a };
     $[0] = a;
@@ -36,9 +35,8 @@ function f(a) {
   }
 
   const t0 = x;
-  const c_2 = $[2] !== t0;
   let t1;
-  if (c_2) {
+  if ($[2] !== t0) {
     t1 = <div x={t0} />;
     $[2] = t0;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/logical-expression-object.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/logical-expression-object.expect.md
index 7b058365de..d0474dda5c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/logical-expression-object.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/logical-expression-object.expect.md
@@ -30,10 +30,8 @@ function component(props) {
 
   const a = props.a || (props.b && props.c && props.d);
   const b = (props.a && props.b && props.c) || props.d;
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     t0 = { a, b };
     $[0] = a;
     $[1] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/maybe-mutate-object-in-callback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/maybe-mutate-object-in-callback.expect.md
index 3820e0283f..438e10b215 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/maybe-mutate-object-in-callback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/maybe-mutate-object-in-callback.expect.md
@@ -51,9 +51,8 @@ function Component(props) {
     t1 = $[1];
   }
   const onClick = t1;
-  const c_2 = $[2] !== props.children;
   let t2;
-  if (c_2) {
+  if ($[2] !== props.children) {
     t2 = <Foo callback={onClick}>{props.children}</Foo>;
     $[2] = props.children;
     $[3] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes-objects.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes-objects.expect.md
index 1c9addf746..b16e1465ac 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes-objects.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes-objects.expect.md
@@ -48,18 +48,16 @@ function Component(props) {
   } else {
     t0 = $[0];
   }
-  const c_1 = $[1] !== state;
   let t1;
-  if (c_1) {
+  if ($[1] !== state) {
     t1 = { component: "span", props: { children: [state] } };
     $[1] = state;
     $[2] = t1;
   } else {
     t1 = $[2];
   }
-  const c_3 = $[3] !== state;
   let t2;
-  if (c_3) {
+  if ($[3] !== state) {
     t2 = () => setState(state + 1);
     $[3] = state;
     $[4] = t2;
@@ -73,9 +71,8 @@ function Component(props) {
   } else {
     t3 = $[5];
   }
-  const c_6 = $[6] !== t2;
   let t4;
-  if (c_6) {
+  if ($[6] !== t2) {
     t4 = {
       component: "button",
       props: { "data-testid": "button", onClick: t2, children: t3 },
@@ -85,10 +82,8 @@ function Component(props) {
   } else {
     t4 = $[7];
   }
-  const c_8 = $[8] !== t1;
-  const c_9 = $[9] !== t4;
   let t5;
-  if (c_8 || c_9) {
+  if ($[8] !== t1 || $[9] !== t4) {
     t5 = [t0, t1, t4];
     $[8] = t1;
     $[9] = t4;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes.expect.md
index a767519e03..43da5bb515 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-consecutive-scopes.expect.md
@@ -37,18 +37,16 @@ function Component() {
   } else {
     t0 = $[0];
   }
-  const c_1 = $[1] !== state;
   let t1;
-  if (c_1) {
+  if ($[1] !== state) {
     t1 = <span>{state}</span>;
     $[1] = state;
     $[2] = t1;
   } else {
     t1 = $[2];
   }
-  const c_3 = $[3] !== state;
   let t2;
-  if (c_3) {
+  if ($[3] !== state) {
     t2 = (
       <button data-testid="button" onClick={() => setState(state + 1)}>
         increment
@@ -59,10 +57,8 @@ function Component() {
   } else {
     t2 = $[4];
   }
-  const c_5 = $[5] !== t1;
-  const c_6 = $[6] !== t2;
   let t3;
-  if (c_5 || c_6) {
+  if ($[5] !== t1 || $[6] !== t2) {
     t3 = (
       <div>
         {t0}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-nested-scopes-with-same-inputs.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-nested-scopes-with-same-inputs.expect.md
index c770b1fd44..8daee27a4f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-nested-scopes-with-same-inputs.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/merge-nested-scopes-with-same-inputs.expect.md
@@ -32,9 +32,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react"; // @enableMergeConsecutiveScopes
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let y;
-  if (c_0) {
+  if ($[0] !== props.a) {
     y = {};
 
     const x = {};
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-computed.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-computed.expect.md
index 50342f1df7..4ac5da71ac 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-computed.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-computed.expect.md
@@ -24,9 +24,8 @@ function foo(a, b, c) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = makeObject(a);
     $[0] = a;
     $[1] = t0;
@@ -34,9 +33,8 @@ function foo(a, b, c) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== a;
   let t1;
-  if (c_2) {
+  if ($[2] !== a) {
     t1 = makeObject(a);
     $[2] = a;
     $[3] = t1;
@@ -44,11 +42,8 @@ function foo(a, b, c) {
     t1 = $[3];
   }
   const y = t1;
-  const c_4 = $[4] !== x;
-  const c_5 = $[5] !== y.method;
-  const c_6 = $[6] !== b;
   let t2;
-  if (c_4 || c_5 || c_6) {
+  if ($[4] !== x || $[5] !== y.method || $[6] !== b) {
     t2 = x[y.method](b);
     $[4] = x;
     $[5] = y.method;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-fn-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-fn-call.expect.md
index 54a8196e43..4c8894e1cd 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-fn-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call-fn-call.expect.md
@@ -21,9 +21,8 @@ function foo(a, b, c) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = makeObject(a);
     $[0] = a;
     $[1] = t0;
@@ -33,11 +32,8 @@ function foo(a, b, c) {
   const x = t0;
 
   const method = x.method;
-  const c_2 = $[2] !== method;
-  const c_3 = $[3] !== x;
-  const c_4 = $[4] !== b;
   let t1;
-  if (c_2 || c_3 || c_4) {
+  if ($[2] !== method || $[3] !== x || $[4] !== b) {
     t1 = method.call(x, b);
     $[2] = method;
     $[3] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call.expect.md
index 1a39884b32..b565e07568 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/method-call.expect.md
@@ -30,9 +30,8 @@ import { addOne, shallowCopy } from "shared-runtime";
 
 function foo(a, b, c) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = shallowCopy(a);
     $[0] = a;
     $[1] = t0;
@@ -40,10 +39,8 @@ function foo(a, b, c) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== x;
-  const c_3 = $[3] !== b;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== x || $[3] !== b) {
     t1 = x.foo(b);
     $[2] = x;
     $[3] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-default-gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-default-gating-test.expect.md
index 7539119009..df3c2a1c9b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-default-gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-default-gating-test.expect.md
@@ -22,9 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating
 const ErrorView = isForgetEnabled_Fixtures()
   ? (error, _retry) => {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== error;
       let t0;
-      if (c_0) {
+      if ($[0] !== error) {
         t0 = <MessageBox error={error} />;
         $[0] = error;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-gating-test.expect.md
index a436ab8c08..ea8acf0d48 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-export-gating-test.expect.md
@@ -22,9 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating
 const ErrorView = isForgetEnabled_Fixtures()
   ? (error, _retry) => {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== error;
       let t0;
-      if (c_0) {
+      if ($[0] !== error) {
         t0 = <MessageBox error={error} />;
         $[0] = error;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-gating-test.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-gating-test.expect.md
index 91c26e597c..e16c9819bc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-gating-test.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/multi-arrow-expr-gating-test.expect.md
@@ -24,9 +24,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @gating
 const ErrorView = isForgetEnabled_Fixtures()
   ? (error, _retry) => {
       const $ = useMemoCache(2);
-      const c_0 = $[0] !== error;
       let t0;
-      if (c_0) {
+      if ($[0] !== error) {
         t0 = <MessageBox error={error} />;
         $[0] = error;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-shadowed-identifiers.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-shadowed-identifiers.expect.md
index 3bbba7884f..8a8d8aecd4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-shadowed-identifiers.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-function-shadowed-identifiers.expect.md
@@ -38,10 +38,8 @@ function Component(props) {
     t0 = $[0];
   }
   const onChange = t0;
-  const c_1 = $[1] !== x;
-  const c_2 = $[2] !== onChange;
   let t1;
-  if (c_1 || c_2) {
+  if ($[1] !== x || $[2] !== onChange) {
     t1 = <input value={x} onChange={onChange} />;
     $[1] = x;
     $[2] = onChange;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-optional-member-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-optional-member-expr.expect.md
index 1b26ffa475..0ca6dd3961 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-optional-member-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/nested-optional-member-expr.expect.md
@@ -19,9 +19,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // We should code
 function Component(props) {
   const $ = useMemoCache(2);
   const t0 = props.a?.b.c.d;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = foo(t0);
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/new-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/new-spread.expect.md
index a843ce474b..7210405237 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/new-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/new-spread.expect.md
@@ -15,10 +15,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.bar;
-  const c_1 = $[1] !== props.foo;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props.bar || $[1] !== props.foo) {
     t0 = new Foo(...props.foo, null, ...[props.bar]);
     $[0] = props.bar;
     $[1] = props.foo;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
index 4953c3f8ab..fc94551a42 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/noAlias-filter-on-array-prop.expect.md
@@ -34,9 +34,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.items;
   let t1;
-  if (c_0) {
+  if ($[0] !== props.items) {
     let t0;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
       t0 = (item) => item != null;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
index 76d7a0a32f..24cd76e11b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-cached-in-if-else.expect.md
@@ -23,9 +23,8 @@ function foo(a, b, c, d) {
   const $ = useMemoCache(4);
   let x = undefined;
   if (someVal) {
-    const c_0 = $[0] !== b;
     let t0;
-    if (c_0) {
+    if ($[0] !== b) {
       t0 = { b };
       $[0] = b;
       $[1] = t0;
@@ -34,9 +33,8 @@ function foo(a, b, c, d) {
     }
     x = t0;
   } else {
-    const c_2 = $[2] !== c;
     let t1;
-    if (c_2) {
+    if ($[2] !== c) {
       t1 = { c };
       $[2] = c;
       $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-mutated-after-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-mutated-after-if-else.expect.md
index 0ef5da016e..8271b1d353 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-mutated-after-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-literal-mutated-after-if-else.expect.md
@@ -22,10 +22,8 @@ function foo(a, b, c, d) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c, d) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== b;
-  const c_1 = $[1] !== c;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== b || $[1] !== c) {
     x = undefined;
     if (someVal) {
       x = { b };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else-with-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else-with-alias.expect.md
index ca446c79b2..b1e28b6697 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else-with-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else-with-alias.expect.md
@@ -25,9 +25,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c, d) {
   const $ = useMemoCache(2);
   someObj();
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = undefined;
     if (a) {
       const y = someObj();
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else.expect.md
index b3c728dbcb..9a8604ede7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-if-else.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c, d) {
   const $ = useMemoCache(2);
   someObj();
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = undefined;
     if (a) {
       x = someObj();
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-nested-if-else-with-alias.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-nested-if-else-with-alias.expect.md
index b407146529..6d7ab19057 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-nested-if-else-with-alias.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/obj-mutated-after-nested-if-else-with-alias.expect.md
@@ -31,10 +31,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c, d) {
   const $ = useMemoCache(3);
   someObj();
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     x = undefined;
     if (a) {
       let z = undefined;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-expression-string-literal-key.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-expression-string-literal-key.expect.md
index 5c7fb76531..46cd8f0b36 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-expression-string-literal-key.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-expression-string-literal-key.expect.md
@@ -21,9 +21,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.foo;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.foo) {
     t0 = { foo: props.foo };
     $[0] = props.foo;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-literal-spread-element.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-literal-spread-element.expect.md
index 367b1b914f..374b3aa4b2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-literal-spread-element.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-literal-spread-element.expect.md
@@ -21,9 +21,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.foo;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.foo) {
     t0 = { ...props.foo };
     $[0] = props.foo;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-pattern-params.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-pattern-params.expect.md
index 11c13a4d32..cd8e2f5a2f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-pattern-params.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-pattern-params.expect.md
@@ -23,9 +23,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component(t16) {
   const $ = useMemoCache(7);
   const { a, b } = t16;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a };
     $[0] = a;
     $[1] = t0;
@@ -33,9 +32,8 @@ function component(t16) {
     t0 = $[1];
   }
   const y = t0;
-  const c_2 = $[2] !== b;
   let t1;
-  if (c_2) {
+  if ($[2] !== b) {
     t1 = { b };
     $[2] = b;
     $[3] = t1;
@@ -43,10 +41,8 @@ function component(t16) {
     t1 = $[3];
   }
   const z = t1;
-  const c_4 = $[4] !== y;
-  const c_5 = $[5] !== z;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== y || $[5] !== z) {
     t2 = { y, z };
     $[4] = y;
     $[5] = z;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-1.expect.md
index a462486d90..784cb29b4f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-1.expect.md
@@ -28,9 +28,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // @debug
 function Component(t16) {
   const $ = useMemoCache(4);
   const { a, b } = t16;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = function () {
       return [a];
     };
@@ -39,9 +38,8 @@ function Component(t16) {
   } else {
     t0 = $[1];
   }
-  const c_2 = $[2] !== t0;
   let t1;
-  if (c_2) {
+  if ($[2] !== t0) {
     t1 = {
       x: t0,
       y() {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
index b2ecf15a60..380ec42ffa 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/object-shorthand-method-2.expect.md
@@ -26,28 +26,24 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(t16) {
   const $ = useMemoCache(7);
   const { a, b, c } = t16;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = [a];
     $[0] = a;
     $[1] = t0;
   } else {
     t0 = $[1];
   }
-  const c_2 = $[2] !== c;
   let t1;
-  if (c_2) {
+  if ($[2] !== c) {
     t1 = { c };
     $[2] = c;
     $[3] = t1;
   } else {
     t1 = $[3];
   }
-  const c_4 = $[4] !== t0;
-  const c_5 = $[5] !== t1;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== t0 || $[5] !== t1) {
     t2 = {
       x: t0,
       y() {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-chained.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-chained.expect.md
index b250957d8d..a652276b0f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-chained.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-chained.expect.md
@@ -14,9 +14,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = call?.(props.a)?.(props.b)?.(props.c);
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-logical.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-logical.expect.md
index 65c736d354..9bd19bfeb4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-logical.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-logical.expect.md
@@ -16,9 +16,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
   const item = useFragment(graphql`...`, props.item);
-  const c_0 = $[0] !== item.items;
   let t0;
-  if (c_0) {
+  if ($[0] !== item.items) {
     t0 = item.items?.map((item_0) => renderItem(item_0)) ?? [];
     $[0] = item.items;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-simple.expect.md
index 62e8b17cfd..e7ef87711c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-simple.expect.md
@@ -14,9 +14,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = foo?.(props);
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-independently-memoizable-arg.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-independently-memoizable-arg.expect.md
index d22f1efc61..2cef112d69 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-independently-memoizable-arg.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-independently-memoizable-arg.expect.md
@@ -24,9 +24,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeOptionalFunction(props);
 
     t0 = x?.(
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-optional-property-load.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-optional-property-load.expect.md
index 285d98837e..ae5a1893d3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-optional-property-load.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call-with-optional-property-load.expect.md
@@ -14,9 +14,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = props?.items?.map?.(render)?.filter(Boolean) ?? [];
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call.expect.md
index 5441290961..20684b407a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-call.expect.md
@@ -17,9 +17,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeOptionalFunction(props);
     const y = makeObject(props);
     t0 = x?.(y.a, props.a, foo(y.b), bar(props.b));
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-computed-member-expression.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-computed-member-expression.expect.md
index ffe5efaed8..8815455a83 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-computed-member-expression.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-computed-member-expression.expect.md
@@ -15,9 +15,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = makeObject(props);
     $[0] = props;
     $[1] = t0;
@@ -25,10 +24,8 @@ function Component(props) {
     t0 = $[1];
   }
   const object = t0;
-  const c_2 = $[2] !== object;
-  const c_3 = $[3] !== props;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== object || $[3] !== props) {
     t1 = object?.[props.key];
     $[2] = object;
     $[3] = props;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-call-as-property.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-call-as-property.expect.md
index 62cfb69f35..dc8e869da7 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-call-as-property.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-call-as-property.expect.md
@@ -23,10 +23,8 @@ function Component(props) {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== props;
-  const c_2 = $[2] !== x;
   let t1;
-  if (c_1 || c_2) {
+  if ($[1] !== props || $[2] !== x) {
     t1 = x?.[foo(props.value)];
     $[1] = props;
     $[2] = x;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-chain.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-chain.expect.md
index fbaf260898..74f45c027a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-chain.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-chain.expect.md
@@ -27,10 +27,8 @@ function Component(props) {
   const $ = useMemoCache(3);
   const x = props?.b.c;
   const y = props?.b.c.d?.e.f.g?.h;
-  const c_0 = $[0] !== x;
-  const c_1 = $[1] !== y;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== x || $[1] !== y) {
     t0 = { x, y };
     $[0] = x;
     $[1] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-with-optional-member-expr-as-property.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-with-optional-member-expr-as-property.expect.md
index e393a0d5a2..67228061de 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-with-optional-member-expr-as-property.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-member-expression-with-optional-member-expr-as-property.expect.md
@@ -23,10 +23,8 @@ function Component(props) {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x.y;
-  const c_2 = $[2] !== props;
   let t1;
-  if (c_1 || c_2) {
+  if ($[1] !== x.y || $[2] !== props) {
     t1 = x.y?.[props.a?.[props.b?.[props.c]]];
     $[1] = x.y;
     $[2] = props;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-method-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-method-call.expect.md
index 507c4f0775..d07c76201d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-method-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-method-call.expect.md
@@ -17,9 +17,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeObject(props);
     const y = makeObject(props);
     t0 = x.optionalMethod?.(y.a, props.a, foo(y.b), bar(props.b));
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-method-call.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-method-call.expect.md
index 5aac758203..91aa2d05e5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-method-call.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-method-call.expect.md
@@ -17,9 +17,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeOptionalObject(props);
     const y = makeObject(props);
     t0 = x?.method(y.a, props.a, foo(y.b), bar(props.b));
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-optional-method.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-optional-method.expect.md
index cb6b417337..46c34ec8ad 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-optional-method.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/optional-receiver-optional-method.expect.md
@@ -17,9 +17,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     const x = makeOptionalObject(props);
     const y = makeObject(props);
     t0 = x?.optionalMethod?.(y.a, props.a, foo(y.b), bar(props.b));
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-shadowing-within-block.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-shadowing-within-block.expect.md
index e163e10479..22d5ffa420 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-shadowing-within-block.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-shadowing-within-block.expect.md
@@ -29,17 +29,12 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [];
     if (a) {
-      const c_4 = $[4] !== b;
-      const c_5 = $[5] !== c;
       let y;
-      if (c_4 || c_5) {
+      if ($[4] !== b || $[5] !== c) {
         y = [];
         if (b) {
           y.push(c);
@@ -50,9 +45,8 @@ function foo(a, b, c) {
       } else {
         y = $[6];
       }
-      const c_7 = $[7] !== y;
       let t0;
-      if (c_7) {
+      if ($[7] !== y) {
         t0 = <div>{y}</div>;
         $[7] = y;
         $[8] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-within-block.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-within-block.expect.md
index 90ec8c0e68..da7252de20 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-within-block.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/overlapping-scopes-within-block.expect.md
@@ -29,17 +29,12 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [];
     if (a) {
-      const c_4 = $[4] !== b;
-      const c_5 = $[5] !== c;
       let y;
-      if (c_4 || c_5) {
+      if ($[4] !== b || $[5] !== c) {
         y = [];
         if (b) {
           y.push(c);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-array-push.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-array-push.expect.md
index 870b88828a..801109a132 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-array-push.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-array-push.expect.md
@@ -33,10 +33,9 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react"; // @debug
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props;
   let x;
   let y;
-  if (c_0) {
+  if ($[0] !== props) {
     x = {};
     y = undefined;
     if (props.cond) {
@@ -53,10 +52,8 @@ function Component(props) {
     x = $[1];
     y = $[2];
   }
-  const c_3 = $[3] !== x;
-  const c_4 = $[4] !== y;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== x || $[4] !== y) {
     t0 = [x, y];
     $[3] = x;
     $[4] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-property-store.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-property-store.expect.md
index 6a3be5878c..4ddb01328f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-property-store.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/phi-type-inference-property-store.expect.md
@@ -41,10 +41,8 @@ function Component(props) {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== props;
-  const c_2 = $[2] !== x;
   let y;
-  if (c_1 || c_2) {
+  if ($[1] !== props || $[2] !== x) {
     y = undefined;
     if (props.cond) {
       y = {};
@@ -59,10 +57,8 @@ function Component(props) {
   } else {
     y = $[3];
   }
-  const c_4 = $[4] !== x;
-  const c_5 = $[5] !== y;
   let t1;
-  if (c_4 || c_5) {
+  if ($[4] !== x || $[5] !== y) {
     t1 = [x, y];
     $[4] = x;
     $[5] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
index 8446f81dfb..9f834b9cf5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep-nested-scope.expect.md
@@ -27,17 +27,14 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.b + 1 is
 //   y depends on either props.b or props.b + 1
 function PrimitiveAsDepNested(props) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== props.b;
-  const c_1 = $[1] !== props.a;
   let x;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== props.b || $[1] !== props.a) {
     x = {};
     mutate(x);
     const t0 = props.b + 1;
-    const c_4 = $[4] !== t0;
     let t1;
-    if (c_4) {
+    if ($[4] !== t0) {
       t1 = foo(t0);
       $[4] = t0;
       $[5] = t1;
@@ -54,10 +51,8 @@ function PrimitiveAsDepNested(props) {
     x = $[2];
     y = $[3];
   }
-  const c_6 = $[6] !== x;
-  const c_7 = $[7] !== y;
   let t2;
-  if (c_6 || c_7) {
+  if ($[6] !== x || $[7] !== y) {
     t2 = [x, y];
     $[6] = x;
     $[7] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep.expect.md
index 119e5d0d7f..b07e9eb1bf 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/primitive-as-dep.expect.md
@@ -25,9 +25,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.b + 1 is
 function PrimitiveAsDep(props) {
   const $ = useMemoCache(2);
   const t0 = props.b + 1;
-  const c_0 = $[0] !== t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== t0) {
     t1 = foo(t0);
     $[0] = t0;
     $[1] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/prop-capturing-function-1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/prop-capturing-function-1.expect.md
index f8398242a4..b77efce92e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/prop-capturing-function-1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/prop-capturing-function-1.expect.md
@@ -24,10 +24,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a, b) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== a || $[1] !== b) {
     t0 = { a, b };
     $[0] = a;
     $[1] = b;
@@ -36,9 +34,8 @@ function component(a, b) {
     t0 = $[2];
   }
   const z = t0;
-  const c_3 = $[3] !== z;
   let t1;
-  if (c_3) {
+  if ($[3] !== z) {
     t1 = function () {
       console.log(z);
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-assignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-assignment.expect.md
index eecc8d3e36..feee0f0fb2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-assignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-assignment.expect.md
@@ -19,10 +19,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props.p0;
   let x;
   let child;
-  if (c_0) {
+  if ($[0] !== props.p0) {
     x = {};
     const y = [];
     x.y = y;
@@ -35,10 +34,8 @@ function Component(props) {
     x = $[1];
     child = $[2];
   }
-  const c_3 = $[3] !== x;
-  const c_4 = $[4] !== child;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== x || $[4] !== child) {
     t0 = <Component data={x}>{child}</Component>;
     $[3] = x;
     $[4] = child;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-call-spread.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-call-spread.expect.md
index 91a98f6487..7fef68ca35 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-call-spread.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/property-call-spread.expect.md
@@ -15,10 +15,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== props.b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== props.b) {
     t0 = foo.bar(...props.a, null, ...props.b);
     $[0] = props.a;
     $[1] = props.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/react-namespace.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/react-namespace.expect.md
index 1525e2b3f4..01f072df64 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/react-namespace.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/react-namespace.expect.md
@@ -39,19 +39,16 @@ function Component(props) {
     ref.current = true;
     foo.current = true;
   };
-  const c_0 = $[0] !== props.children;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.children) {
     t0 = React.cloneElement(props.children);
     $[0] = props.children;
     $[1] = t0;
   } else {
     t0 = $[1];
   }
-  const c_2 = $[2] !== onClick;
-  const c_3 = $[3] !== t0;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== onClick || $[3] !== t0) {
     t1 = <div onClick={onClick}>{t0}</div>;
     $[2] = onClick;
     $[3] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-dependencies-non-optional-properties-inside-optional-chain.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-dependencies-non-optional-properties-inside-optional-chain.expect.md
index 1fa0d3b170..98e74ddd85 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-dependencies-non-optional-properties-inside-optional-chain.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-dependencies-non-optional-properties-inside-optional-chain.expect.md
@@ -14,9 +14,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.post.feedback.comments;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.post.feedback.comments) {
     t0 = props.post.feedback.comments?.edges?.map(render);
     $[0] = props.post.feedback.comments;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes-if.expect.md
index 9a257b0b6b..e6f9fd3849 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes-if.expect.md
@@ -28,16 +28,12 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c) {
     x = [];
     if (a) {
-      const c_4 = $[4] !== b;
       let y;
-      if (c_4) {
+      if ($[4] !== b) {
         y = [];
         y.push(b);
         $[4] = b;
@@ -45,9 +41,8 @@ function foo(a, b, c) {
       } else {
         y = $[5];
       }
-      const c_6 = $[6] !== y;
       let t0;
-      if (c_6) {
+      if ($[6] !== y) {
         t0 = <div>{y}</div>;
         $[6] = y;
         $[7] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes.expect.md
index 45da8b957d..e47b4bfb7f 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactive-scopes.expect.md
@@ -27,10 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function f(a, b) {
   const $ = useMemoCache(5);
-  const c_0 = $[0] !== a.length;
-  const c_1 = $[1] !== b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== a.length || $[1] !== b) {
     x = [];
     if (a.length === 1) {
       if (b) {
@@ -43,9 +41,8 @@ function f(a, b) {
   } else {
     x = $[2];
   }
-  const c_3 = $[3] !== x;
   let t0;
-  if (c_3) {
+  if ($[3] !== x) {
     t0 = <div>{x}</div>;
     $[3] = x;
     $[4] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-interleaved-reactivity.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-interleaved-reactivity.expect.md
index ab0db47a75..22d2109a07 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-interleaved-reactivity.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-interleaved-reactivity.expect.md
@@ -36,9 +36,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props.b;
   let a;
-  if (c_0) {
+  if ($[0] !== props.b) {
     a = {};
     const b = [];
     b.push(props.b);
@@ -48,9 +47,8 @@ function Component(props) {
   } else {
     a = $[1];
   }
-  const c_2 = $[2] !== a;
   let t0;
-  if (c_2) {
+  if ($[2] !== a) {
     t0 = [a];
     $[2] = a;
     $[3] = t0;
@@ -58,9 +56,8 @@ function Component(props) {
     t0 = $[3];
   }
   const c = t0;
-  const c_4 = $[4] !== a;
   let t1;
-  if (c_4) {
+  if ($[4] !== a) {
     t1 = [c, a];
     $[4] = a;
     $[5] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-computed-load.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-computed-load.expect.md
index 8f6a59fb01..1d9efeeaac 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-computed-load.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-computed-load.expect.md
@@ -19,10 +19,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.key;
-  const c_1 = $[1] !== props.a;
   let items;
-  if (c_0 || c_1) {
+  if ($[0] !== props.key || $[1] !== props.a) {
     items = bar();
     mutate(items[props.key], props.a);
     $[0] = props.key;
@@ -33,9 +31,8 @@ function Component(props) {
   }
 
   const t0 = items.length + 1;
-  const c_3 = $[3] !== t0;
   let t1;
-  if (c_3) {
+  if ($[3] !== t0) {
     t1 = foo(t0);
     $[3] = t0;
     $[4] = t1;
@@ -43,10 +40,8 @@ function Component(props) {
     t1 = $[4];
   }
   const count = t1;
-  const c_5 = $[5] !== items;
-  const c_6 = $[6] !== count;
   let t2;
-  if (c_5 || c_6) {
+  if ($[5] !== items || $[6] !== count) {
     t2 = { items, count };
     $[5] = items;
     $[6] = count;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-property-load.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-property-load.expect.md
index 0bb54683ce..07337929ea 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-property-load.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reactivity-analysis-reactive-via-mutation-of-property-load.expect.md
@@ -19,9 +19,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(7);
-  const c_0 = $[0] !== props.a;
   let items;
-  if (c_0) {
+  if ($[0] !== props.a) {
     items = bar();
     mutate(items.a, props.a);
     $[0] = props.a;
@@ -31,9 +30,8 @@ function Component(props) {
   }
 
   const t0 = items.length + 1;
-  const c_2 = $[2] !== t0;
   let t1;
-  if (c_2) {
+  if ($[2] !== t0) {
     t1 = foo(t0);
     $[2] = t0;
     $[3] = t1;
@@ -41,10 +39,8 @@ function Component(props) {
     t1 = $[3];
   }
   const count = t1;
-  const c_4 = $[4] !== items;
-  const c_5 = $[5] !== count;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== items || $[5] !== count) {
     t2 = { items, count };
     $[4] = items;
     $[5] = count;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls-mutable-lambda.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls-mutable-lambda.expect.md
index 8d4eb5e618..e76848c199 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls-mutable-lambda.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls-mutable-lambda.expect.md
@@ -45,9 +45,8 @@ function Component(props) {
   posts.push(t0);
   const count = posts.length;
   foo(count);
-  const c_1 = $[1] !== posts;
   let t1;
-  if (c_1) {
+  if ($[1] !== posts) {
     t1 = <>{posts}</>;
     $[1] = posts;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
index fd396ef3ac..510cbcd93a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/readonly-object-method-calls.expect.md
@@ -28,9 +28,8 @@ function Component(props) {
     graphql`fragment Component_user on User { ... }`,
     props.user
   );
-  const c_0 = $[0] !== user.timeline.posts.edges.nodes;
   let posts;
-  if (c_0) {
+  if ($[0] !== user.timeline.posts.edges.nodes) {
     posts = user.timeline.posts.edges.nodes.map((node) => <Post post={node} />);
     let t0;
     if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
@@ -47,9 +46,8 @@ function Component(props) {
   }
   const count = posts.length;
   foo(count);
-  const c_3 = $[3] !== posts;
   let t1;
-  if (c_3) {
+  if ($[3] !== posts) {
     t1 = <>{posts}</>;
     $[3] = posts;
     $[4] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassigned-phi-in-returned-function-expression.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassigned-phi-in-returned-function-expression.expect.md
index 3b093b9fa1..22ea5bbce3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassigned-phi-in-returned-function-expression.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassigned-phi-in-returned-function-expression.expect.md
@@ -22,9 +22,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.str;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.str) {
     t0 = () => {
       let str = undefined;
       if (arguments.length) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
index 848e3f6164..ea814d9cf9 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-conditional.expect.md
@@ -24,12 +24,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== props.p0;
-  const c_1 = $[1] !== props.p1;
-  const c_2 = $[2] !== props.p2;
   let x;
   let y;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.p0 || $[1] !== props.p1 || $[2] !== props.p2) {
     x = [];
     x.push(props.p0);
     y = x;
@@ -54,10 +51,8 @@ function Component(props) {
     x = $[3];
     y = $[4];
   }
-  const c_6 = $[6] !== x;
-  const c_7 = $[7] !== y;
   let t1;
-  if (c_6 || c_7) {
+  if ($[6] !== x || $[7] !== y) {
     t1 = <Component x={x} y={y} />;
     $[6] = x;
     $[7] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-separate-scopes.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-separate-scopes.expect.md
index a4877fb99c..7ff467add4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-separate-scopes.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment-separate-scopes.expect.md
@@ -42,9 +42,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a, b, c) {
   const $ = useMemoCache(11);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = [];
     if (a) {
       x.push(a);
@@ -54,9 +53,8 @@ function foo(a, b, c) {
   } else {
     x = $[1];
   }
-  const c_2 = $[2] !== x;
   let t0;
-  if (c_2) {
+  if ($[2] !== x) {
     t0 = <div>{x}</div>;
     $[2] = x;
     $[3] = t0;
@@ -66,8 +64,7 @@ function foo(a, b, c) {
   const y = t0;
   bb3: switch (b) {
     case 0: {
-      const c_4 = $[4] !== b;
-      if (c_4) {
+      if ($[4] !== b) {
         x = [];
         x.push(b);
         $[4] = b;
@@ -78,8 +75,7 @@ function foo(a, b, c) {
       break bb3;
     }
     default: {
-      const c_6 = $[6] !== c;
-      if (c_6) {
+      if ($[6] !== c) {
         x = [];
         x.push(c);
         $[6] = c;
@@ -89,10 +85,8 @@ function foo(a, b, c) {
       }
     }
   }
-  const c_8 = $[8] !== y;
-  const c_9 = $[9] !== x;
   let t1;
-  if (c_8 || c_9) {
+  if ($[8] !== y || $[9] !== x) {
     t1 = (
       <div>
         {y}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
index 772438d0ef..72e6704a6b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reassignment.expect.md
@@ -23,11 +23,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.p0;
-  const c_1 = $[1] !== props.p1;
   let x;
   let y;
-  if (c_0 || c_1) {
+  if ($[0] !== props.p0 || $[1] !== props.p1) {
     x = [];
     x.push(props.p0);
     y = x;
@@ -49,10 +47,8 @@ function Component(props) {
     x = $[2];
     y = $[3];
   }
-  const c_5 = $[5] !== x;
-  const c_6 = $[6] !== y;
   let t1;
-  if (c_5 || c_6) {
+  if ($[5] !== x || $[6] !== y) {
     t1 = <Component x={x} y={y} />;
     $[5] = x;
     $[6] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-condexpr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-condexpr.expect.md
index fc8c2448b3..3bcc589a35 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-condexpr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-condexpr.expect.md
@@ -22,10 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInConditionalExpr(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a.b;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a.b) {
     t0 = foo(other) ? bar(props.a.b) : baz(props.a.b);
     $[0] = other;
     $[1] = props.a.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-ifelse.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-ifelse.expect.md
index 99edb89072..86a20e6905 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-ifelse.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-ifelse.expect.md
@@ -27,10 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInDirectIfElse(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a.b) {
     x = {};
     if (foo(other)) {
       x.b = props.a.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse-missing.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse-missing.expect.md
index f7d1b7006d..cd12a56dab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse-missing.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse-missing.expect.md
@@ -27,10 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInNestedIfElse(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props) {
     x = {};
     if (foo(other)) {
       if (bar()) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse.expect.md
index 4e2512d24b..590ab88efb 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-ifelse.expect.md
@@ -33,10 +33,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInNestedIfElse(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a.b) {
     x = {};
     if (foo(other)) {
       if (bar()) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-testifelse.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-testifelse.expect.md
index fd6db47747..410973e358 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-testifelse.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-nested-testifelse.expect.md
@@ -40,10 +40,8 @@ import { setProperty } from "shared-runtime";
 function useFoo(t27) {
   const $ = useMemoCache(3);
   const { o, branchCheck } = t27;
-  const c_0 = $[0] !== branchCheck;
-  const c_1 = $[1] !== o.value;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== branchCheck || $[1] !== o.value) {
     x = {};
     if (branchCheck) {
       setProperty(x, o.value);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-case.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-case.expect.md
index 16c4e7d234..b7e474724d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-case.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-case.expect.md
@@ -31,10 +31,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInSwitchMissingCase(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props) {
     x = {};
     bb1: switch (foo(other)) {
       case 1: {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-default.expect.md
index 27d0f2dea8..a085fe856d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch-missing-default.expect.md
@@ -28,10 +28,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInSwitchMissingDefault(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props) {
     x = {};
     bb1: switch (foo(other)) {
       case 1: {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch.expect.md
index 340c06f116..d069d92d41 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-cfg-switch.expect.md
@@ -32,10 +32,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // props.a.b shou
 
 function TestCondDepInSwitch(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a.b;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a.b) {
     x = {};
     bb1: switch (foo(other)) {
       case 1: {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-no-uncond.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-no-uncond.expect.md
index 9ccab0e33d..fb4a853d49 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-no-uncond.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-no-uncond.expect.md
@@ -22,10 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When an object
 // track the base object as a dependency.
 function TestOnlyConditionalDependencies(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props) {
     x = {};
     if (foo(other)) {
       x.b = props.a.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-promote-uncond.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-promote-uncond.expect.md
index 77d25c6bd5..f0a95b9a01 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-promote-uncond.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-promote-uncond.expect.md
@@ -24,10 +24,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When a conditi
 // and promote it to an unconditional dependency.
 function TestPromoteUnconditionalAccessToDependency(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== other;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== other) {
     x = {};
     x.a = props.a.a.a;
     if (foo(other)) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order1.expect.md
index c9361ceab1..3d6c5a4951 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order1.expect.md
@@ -28,10 +28,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When a conditi
 // ordering of accesses should not matter
 function TestConditionalSubpath1(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== other;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== other) {
     x = {};
     x.b = props.a.b;
     if (foo(other)) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order2.expect.md
index 3fd5902b4c..60bd29612b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-subpath-order2.expect.md
@@ -28,10 +28,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When a conditi
 // ordering of accesses should not matter
 function TestConditionalSubpath2(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a) {
     x = {};
     if (foo(other)) {
       x.a = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order1.expect.md
index bab501642a..84f1191740 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order1.expect.md
@@ -26,10 +26,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When an uncond
 // ordering of accesses should not matter
 function TestConditionalSuperpath1(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
-  const c_1 = $[1] !== other;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a || $[1] !== other) {
     x = {};
     x.a = props.a;
     if (foo(other)) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order2.expect.md
index 5f23bdfbbb..878a4d215e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-deps-superpath-order2.expect.md
@@ -26,10 +26,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // When an uncond
 // ordering of accesses should not matter
 function TestConditionalSuperpath2(props, other) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== other;
-  const c_1 = $[1] !== props.a;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== other || $[1] !== props.a) {
     x = {};
     if (foo(other)) {
       x.b = props.a.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-memberexpr-join.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-memberexpr-join.expect.md
index 864592ee52..4d3433f5a3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-memberexpr-join.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-cond-memberexpr-join.expect.md
@@ -44,9 +44,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // To preserve th
 
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = [];
     x.push(props.a?.b);
     x.push(props.a.b.c);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-dependencies-optional-member-expression.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-dependencies-optional-member-expression.expect.md
index 5c827f6154..790d8922d2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-dependencies-optional-member-expression.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-dependencies-optional-member-expression.expect.md
@@ -17,9 +17,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.items;
   let x;
-  if (c_0) {
+  if ($[0] !== props.items) {
     x = [];
     x.push(props.items?.length);
     x.push(props.items?.edges?.map?.(render)?.filter?.(Boolean) ?? []);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-cond-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-cond-scope.expect.md
index a381370143..b6c35d230a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-cond-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-cond-scope.expect.md
@@ -54,14 +54,12 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Some reactive
 
 function TestReactiveDepsInCondScope(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = {};
     if (foo) {
-      const c_2 = $[2] !== props.a.b;
       let t0;
-      if (c_2) {
+      if ($[2] !== props.a.b) {
         t0 = bar(props.a.b);
         $[2] = props.a.b;
         $[3] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-join-uncond-scopes-cond-deps.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-join-uncond-scopes-cond-deps.expect.md
index 813cdbf5c4..7d4c1b0d6b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-join-uncond-scopes-cond-deps.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-deps-join-uncond-scopes-cond-deps.expect.md
@@ -53,13 +53,11 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // This tests an
 
 function TestJoinCondDepsInUncondScopes(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props.a.b;
   let x;
   let y;
-  if (c_0) {
+  if ($[0] !== props.a.b) {
     y = {};
-    const c_3 = $[3] !== props;
-    if (c_3) {
+    if ($[3] !== props) {
       x = {};
       if (foo) {
         mutate1(x, props.a.b);
@@ -78,10 +76,8 @@ function TestJoinCondDepsInUncondScopes(props) {
     x = $[1];
     y = $[2];
   }
-  const c_5 = $[5] !== x;
-  const c_6 = $[6] !== y;
   let t0;
-  if (c_5 || c_6) {
+  if ($[5] !== x || $[6] !== y) {
     t0 = [x, y];
     $[5] = x;
     $[6] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-descendant.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-descendant.expect.md
index 7345237512..fa59dea198 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-descendant.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-descendant.expect.md
@@ -27,11 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Test that we c
 // (not needed for correctness but for dependency granularity)
 function TestNonOverlappingDescendantTracked(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.a.x.y;
-  const c_1 = $[1] !== props.a.c.x.y.z;
-  const c_2 = $[2] !== props.b;
   let x;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== props.a.x.y || $[1] !== props.a.c.x.y.z || $[2] !== props.b) {
     x = {};
     x.a = props.a.x.y;
     x.b = props.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-direct.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-direct.expect.md
index a1bb6112c0..b0f402fe47 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-direct.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-nonoverlap-direct.expect.md
@@ -26,10 +26,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Test that we c
 // (not needed for correctness but for dependency granularity)
 function TestNonOverlappingTracked(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a.b;
-  const c_1 = $[1] !== props.a.c;
   let x;
-  if (c_0 || c_1) {
+  if ($[0] !== props.a.b || $[1] !== props.a.c) {
     x = {};
     x.b = props.a.b;
     x.c = props.a.c;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-descendant.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-descendant.expect.md
index a4f23db54a..89e2420c5d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-descendant.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-descendant.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Test that we c
 // a dependency
 function TestOverlappingDescendantTracked(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = {};
     x.b = props.a.b.c;
     x.c = props.a.b.c.x.y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-direct.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-direct.expect.md
index 6a283f7a53..313c3fdc1b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-direct.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-overlap-direct.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Test that we c
 // a dependency
 function TestOverlappingTracked(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = {};
     x.b = props.a.b;
     x.c = props.a.c;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order1.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order1.expect.md
index c95b11e5c3..390acd0c22 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order1.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order1.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Determine that
 // Ordering of access should not matter
 function TestDepsSubpathOrder1(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = {};
     x.b = props.a.b;
     x.a = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order2.expect.md
index 0b69456511..2e5f030329 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order2.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Determine that
 // Ordering of access should not matter
 function TestDepsSubpathOrder2(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = {};
     x.a = props.a;
     x.b = props.a.b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order3.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order3.expect.md
index fb8ae6c905..b53c8006bf 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order3.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/reduce-reactive-uncond-deps-subpath-order3.expect.md
@@ -27,9 +27,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Determine that
 // Ordering of access should not matter
 function TestDepsSubpathOrder3(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = {};
     x.c = props.a.b.c;
     x.a = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-no-added-to-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-no-added-to-dep.expect.md
index d5123308cf..292fbf0b6d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-no-added-to-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-no-added-to-dep.expect.md
@@ -33,9 +33,8 @@ function VideoTab() {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x;
   let t1;
-  if (c_1) {
+  if ($[1] !== x) {
     t1 = <VideoList videos={x} />;
     $[1] = x;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-not-added-to-dep-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-not-added-to-dep-2.expect.md
index caf1faa54f..3725d01815 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-not-added-to-dep-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-aliased-not-added-to-dep-2.expect.md
@@ -21,9 +21,8 @@ function Foo(t20) {
   const { a } = t20;
   const ref = useRef();
   const val = ref.current;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a, val };
     $[0] = a;
     $[1] = t0;
@@ -31,9 +30,8 @@ function Foo(t20) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== x;
   let t1;
-  if (c_2) {
+  if ($[2] !== x) {
     t1 = <VideoList videos={x} />;
     $[2] = x;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-field-not-added-to-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-field-not-added-to-dep.expect.md
index 0eb838997a..a4c2dfc069 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-field-not-added-to-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-field-not-added-to-dep.expect.md
@@ -31,9 +31,8 @@ function VideoTab() {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x;
   let t1;
-  if (c_1) {
+  if ($[1] !== x) {
     t1 = <VideoList videos={x} />;
     $[1] = x;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep-2.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep-2.expect.md
index 5074bc6bd6..d9c0147aa5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep-2.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep-2.expect.md
@@ -19,9 +19,8 @@ function Foo(t17) {
   const $ = useMemoCache(4);
   const { a } = t17;
   const ref = useRef();
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = { a, val: ref.current };
     $[0] = a;
     $[1] = t0;
@@ -29,9 +28,8 @@ function Foo(t17) {
     t0 = $[1];
   }
   const x = t0;
-  const c_2 = $[2] !== x;
   let t1;
-  if (c_2) {
+  if ($[2] !== x) {
     t1 = <VideoList videos={x} />;
     $[2] = x;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep.expect.md
index 2f826ef998..12dc6c7486 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-not-added-to-dep.expect.md
@@ -30,9 +30,8 @@ function VideoTab() {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x;
   let t1;
-  if (c_1) {
+  if ($[1] !== x) {
     t1 = <VideoList videos={x} />;
     $[1] = x;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-optional-field-no-added-to-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-optional-field-no-added-to-dep.expect.md
index 6fe9a28cbb..fc92166eb6 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-optional-field-no-added-to-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-optional-field-no-added-to-dep.expect.md
@@ -30,9 +30,8 @@ function VideoTab() {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x;
   let t1;
-  if (c_1) {
+  if ($[1] !== x) {
     t1 = <VideoList videos={x} />;
     $[1] = x;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-write-not-added-to-dep.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-write-not-added-to-dep.expect.md
index 6b6b95e201..ee94ee63ba 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-write-not-added-to-dep.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-current-write-not-added-to-dep.expect.md
@@ -30,9 +30,8 @@ function VideoTab() {
     t0 = $[0];
   }
   const x = t0;
-  const c_1 = $[1] !== x;
   let t1;
-  if (c_1) {
+  if ($[1] !== x) {
     t1 = <VideoList videos={x} />;
     $[1] = x;
     $[2] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-in-effect.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-in-effect.expect.md
index 6af6facbed..aee9898e48 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-in-effect.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ref-in-effect.expect.md
@@ -44,9 +44,8 @@ function Component(props) {
     t1 = $[1];
   }
   useEffect(t1);
-  const c_2 = $[2] !== onChange;
   let t2;
-  if (c_2) {
+  if ($[2] !== onChange) {
     t2 = <Foo onChange={onChange} />;
     $[2] = onChange;
     $[3] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-import-specifier.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-import-specifier.expect.md
index 3103f0bcb4..f3a00bd08d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-import-specifier.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-import-specifier.expect.md
@@ -26,9 +26,8 @@ import { useState, unstable_useMemoCache as useMemoCache } from "react";
 function Component(_props) {
   const $ = useMemoCache(2);
   const [x] = useState(0);
-  const c_0 = $[0] !== x;
   let t0;
-  if (c_0) {
+  if ($[0] !== x) {
     t0 = { x };
     $[0] = x;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-instruction-from-merge-consecutive-scopes.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-instruction-from-merge-consecutive-scopes.expect.md
index 69e3c3a64c..13b18fab78 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-instruction-from-merge-consecutive-scopes.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-duplicate-instruction-from-merge-consecutive-scopes.expect.md
@@ -38,9 +38,8 @@ function Component(id) {
     t0 = $[0];
   }
   const t1 = id ? true : false;
-  const c_1 = $[1] !== t1;
   let t2;
-  if (c_1) {
+  if ($[1] !== t1) {
     t2 = (
       <>
         {t0}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
index a5cc1f8f16..7a271c5f3d 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-reassign-to-variable-without-mutable-range.expect.md
@@ -38,15 +38,12 @@ function Component(a, b) {
     t1 = $[1];
   }
   let y = t1;
-  const c_2 = $[2] !== a;
-  const c_3 = $[3] !== b;
-  if (c_2 || c_3) {
+  if ($[2] !== a || $[3] !== b) {
     const z = foo(a);
     if (FLAG) {
       x = bar(z);
-      const c_6 = $[6] !== b;
       let t2;
-      if (c_6) {
+      if ($[6] !== b) {
         t2 = baz(b);
         $[6] = b;
         $[7] = t2;
@@ -63,10 +60,8 @@ function Component(a, b) {
     x = $[4];
     y = $[5];
   }
-  const c_8 = $[8] !== x;
-  const c_9 = $[9] !== y;
   let t3;
-  if (c_8 || c_9) {
+  if ($[8] !== x || $[9] !== y) {
     t3 = [x, y];
     $[8] = x;
     $[9] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-scope-missing-mutable-range.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-scope-missing-mutable-range.expect.md
index d5cd24eeac..e069671fab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-scope-missing-mutable-range.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro-scope-missing-mutable-range.expect.md
@@ -22,9 +22,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function HomeDiscoStoreItemTileRating(props) {
   const $ = useMemoCache(3);
   const item = useFragment();
-  const c_0 = $[0] !== item;
   let count;
-  if (c_0) {
+  if ($[0] !== item) {
     count = 0;
     const aggregates = item?.aggregates || [];
     aggregates.forEach((aggregate) => {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro.expect.md
index 104f846e05..4fdf1c599a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/repro.expect.md
@@ -26,10 +26,9 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
   const item = props.item;
-  const c_0 = $[0] !== item;
   let baseVideos;
   let thumbnails;
-  if (c_0) {
+  if ($[0] !== item) {
     thumbnails = [];
     baseVideos = getBaseVideos(item);
 
@@ -46,10 +45,8 @@ function Component(props) {
     baseVideos = $[1];
     thumbnails = $[2];
   }
-  const c_3 = $[3] !== baseVideos;
-  const c_4 = $[4] !== thumbnails;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== baseVideos || $[4] !== thumbnails) {
     t0 = <FlatList baseVideos={baseVideos} items={thumbnails} />;
     $[3] = baseVideos;
     $[4] = thumbnails;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-array-pattern.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-array-pattern.expect.md
index 17a63793fb..032f7091cc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-array-pattern.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-array-pattern.expect.md
@@ -20,10 +20,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(foo, ...t9) {
   const $ = useMemoCache(3);
   const [bar] = t9;
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     t0 = [foo, bar];
     $[0] = foo;
     $[1] = bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-identifier.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-identifier.expect.md
index e11d8aff2a..de2330a95b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-identifier.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-identifier.expect.md
@@ -20,10 +20,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(foo, ...t9) {
   const $ = useMemoCache(3);
   const bar = t9;
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     t0 = [foo, bar];
     $[0] = foo;
     $[1] = bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-object-spread-pattern.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-object-spread-pattern.expect.md
index 7420d93d45..16e76a6d19 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-object-spread-pattern.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rest-param-with-object-spread-pattern.expect.md
@@ -20,10 +20,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(foo, ...t9) {
   const $ = useMemoCache(3);
   const { bar } = t9;
-  const c_0 = $[0] !== foo;
-  const c_1 = $[1] !== bar;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== foo || $[1] !== bar) {
     t0 = [foo, bar];
     $[0] = foo;
     $[1] = bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-9a47e97b5d13.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-9a47e97b5d13.expect.md
index d14c4d9de7..4b92db56ed 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-9a47e97b5d13.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-9a47e97b5d13.expect.md
@@ -19,10 +19,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Valid because
 const FancyButton = React.forwardRef(function (props, ref) {
   const $ = useMemoCache(3);
   useHook();
-  const c_0 = $[0] !== props;
-  const c_1 = $[1] !== ref;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props || $[1] !== ref) {
     t0 = <button {...props} ref={ref} />;
     $[0] = props;
     $[1] = ref;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-e66a744cffbe.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-e66a744cffbe.expect.md
index 25ed1c43d4..d4cf7ad833 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-e66a744cffbe.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-e66a744cffbe.expect.md
@@ -19,10 +19,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Valid because
 const FancyButton = forwardRef(function (props, ref) {
   const $ = useMemoCache(3);
   useHook();
-  const c_0 = $[0] !== props;
-  const c_1 = $[1] !== ref;
   let t0;
-  if (c_0 || c_1) {
+  if ($[0] !== props || $[1] !== ref) {
     t0 = <button {...props} ref={ref} />;
     $[0] = props;
     $[1] = ref;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-eacfcaa6ef89.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-eacfcaa6ef89.expect.md
index e37104ccc6..058c9f0095 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-eacfcaa6ef89.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/rules-of-hooks/rules-of-hooks-eacfcaa6ef89.expect.md
@@ -19,9 +19,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // Valid because
 const MemoizedFunction = memo(function (props) {
   const $ = useMemoCache(2);
   useHook();
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = <button {...props} />;
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare-maybe-frozen.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare-maybe-frozen.expect.md
index 24e5f08bf5..6555467e87 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare-maybe-frozen.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare-maybe-frozen.expect.md
@@ -53,9 +53,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // note: comments
 // emitted
 function foo(props) {
   const $ = useMemoCache(16);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = [];
     x.push(props.a);
     $[0] = props.a;
@@ -63,10 +62,8 @@ function foo(props) {
   } else {
     x = $[1];
   }
-  const c_2 = $[2] !== props.showHeader;
-  const c_3 = $[3] !== x;
   let t0;
-  if (c_2 || c_3) {
+  if ($[2] !== props.showHeader || $[3] !== x) {
     t0 = props.showHeader ? <div>{x}</div> : null;
     $[2] = props.showHeader;
     $[3] = x;
@@ -75,11 +72,8 @@ function foo(props) {
     t0 = $[4];
   }
   const header = t0;
-  const c_5 = $[5] !== x;
-  const c_6 = $[6] !== props.b;
-  const c_7 = $[7] !== props.c;
   let y;
-  if (c_5 || c_6 || c_7) {
+  if ($[5] !== x || $[6] !== props.b || $[7] !== props.c) {
     y = [x];
     x = [];
     y.push(props.b);
@@ -93,10 +87,8 @@ function foo(props) {
     y = $[8];
     x = $[9];
   }
-  const c_10 = $[10] !== x;
-  const c_11 = $[11] !== y;
   let t1;
-  if (c_10 || c_11) {
+  if ($[10] !== x || $[11] !== y) {
     t1 = (
       <div>
         {x}
@@ -110,10 +102,8 @@ function foo(props) {
     t1 = $[12];
   }
   const content = t1;
-  const c_13 = $[13] !== header;
-  const c_14 = $[14] !== content;
   let t2;
-  if (c_13 || c_14) {
+  if ($[13] !== header || $[14] !== content) {
     t2 = (
       <>
         {header}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare.expect.md
index 681edc3526..dc9726798c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/same-variable-as-dep-and-redeclare.expect.md
@@ -53,9 +53,8 @@ import { unstable_useMemoCache as useMemoCache } from "react"; // note: comments
 // emitted
 function foo(props) {
   const $ = useMemoCache(15);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = [];
     x.push(props.a);
     $[0] = props.a;
@@ -63,9 +62,8 @@ function foo(props) {
   } else {
     x = $[1];
   }
-  const c_2 = $[2] !== x;
   let t0;
-  if (c_2) {
+  if ($[2] !== x) {
     t0 = <div>{x}</div>;
     $[2] = x;
     $[3] = t0;
@@ -73,11 +71,8 @@ function foo(props) {
     t0 = $[3];
   }
   const header = t0;
-  const c_4 = $[4] !== x;
-  const c_5 = $[5] !== props.b;
-  const c_6 = $[6] !== props.c;
   let y;
-  if (c_4 || c_5 || c_6) {
+  if ($[4] !== x || $[5] !== props.b || $[6] !== props.c) {
     y = [x];
     x = [];
     y.push(props.b);
@@ -91,10 +86,8 @@ function foo(props) {
     y = $[7];
     x = $[8];
   }
-  const c_9 = $[9] !== x;
-  const c_10 = $[10] !== y;
   let t1;
-  if (c_9 || c_10) {
+  if ($[9] !== x || $[10] !== y) {
     t1 = (
       <div>
         {x}
@@ -108,10 +101,8 @@ function foo(props) {
     t1 = $[11];
   }
   const content = t1;
-  const c_12 = $[12] !== header;
-  const c_13 = $[13] !== content;
   let t2;
-  if (c_12 || c_13) {
+  if ($[12] !== header || $[13] !== content) {
     t2 = (
       <>
         {header}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple-scope.expect.md
index 089afa7381..63a06c3ab0 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple-scope.expect.md
@@ -21,9 +21,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a.b;
   let t0;
-  if (c_0) {
+  if ($[0] !== a.b) {
     t0 = [a.b];
     $[0] = a.b;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
index 897efa572f..f9db864301 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/simple.expect.md
@@ -18,9 +18,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 export default function foo(x, y) {
   const $ = useMemoCache(4);
   if (x) {
-    const c_0 = $[0] !== y;
     let t0;
-    if (c_0) {
+    if ($[0] !== y) {
       t0 = foo(false, y);
       $[0] = y;
       $[1] = t0;
@@ -31,9 +30,8 @@ export default function foo(x, y) {
   }
 
   const t1 = y * 10;
-  const c_2 = $[2] !== t1;
   let t2;
-  if (c_2) {
+  if ($[2] !== t1) {
     t2 = [t1];
     $[2] = t1;
     $[3] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-cascading-eliminated-phis.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-cascading-eliminated-phis.expect.md
index 208c5f4d19..e4e001a547 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-cascading-eliminated-phis.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-cascading-eliminated-phis.expect.md
@@ -33,9 +33,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(3);
   let x = 0;
-  const c_0 = $[0] !== props;
   let values;
-  if (c_0) {
+  if ($[0] !== props) {
     values = [];
     const y = props.a || props.b;
     values.push(y);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-leave-case.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-leave-case.expect.md
index 17506f2c49..f01fa5f160 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-leave-case.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-leave-case.expect.md
@@ -25,10 +25,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props;
   let x;
   let y;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     if (props.p0) {
       x.push(props.p1);
@@ -41,10 +40,8 @@ function Component(props) {
     x = $[1];
     y = $[2];
   }
-  const c_3 = $[3] !== x;
-  const c_4 = $[4] !== y;
   let t0;
-  if (c_3 || c_4) {
+  if ($[3] !== x || $[4] !== y) {
     t0 = (
       <Component>
         {x}
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-alias-mutate-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-alias-mutate-if.expect.md
index 7d82e07f26..6cd6365216 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-alias-mutate-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-alias-mutate-if.expect.md
@@ -24,9 +24,8 @@ function foo(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     const b = {};
     x = b;
     if (a) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
index 4be337cfa6..204e141965 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-if.expect.md
@@ -28,9 +28,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = {};
     if (a) {
       let t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-if.expect.md
index 78795df329..80f0f47a3e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-if.expect.md
@@ -23,9 +23,8 @@ function foo(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = {};
     if (a) {
       const y = {};
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-inside-if.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-inside-if.expect.md
index b54f2ba730..d983730ec4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-inside-if.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-property-alias-mutate-inside-if.expect.md
@@ -23,9 +23,8 @@ function foo(a) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(a) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== a;
   let x;
-  if (c_0) {
+  if ($[0] !== a) {
     x = {};
     if (a) {
       const y = {};
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction-with-mutation.expect.md
index c0fc088d24..d4bd9d7f65 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction-with-mutation.expect.md
@@ -18,9 +18,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     x.push(props.bar);
     props.cond ? (([x] = [[]]), x.push(props.foo)) : null;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction.expect.md
index 7abf9e0f6d..3466e4a11c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-destruction.expect.md
@@ -23,9 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let x;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     x = [];
     x.push(props.bar);
     $[0] = props.bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-with-mutation.expect.md
index 913d51ce0a..9087ad6151 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary-with-mutation.expect.md
@@ -18,9 +18,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     x.push(props.bar);
     props.cond ? ((x = []), x.push(props.foo)) : null;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary.expect.md
index 73927a169a..fec0845332 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-ternary.expect.md
@@ -23,9 +23,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let x;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     x = [];
     x.push(props.bar);
     $[0] = props.bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary-with-mutation.expect.md
index e6ea666e07..9777981965 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary-with-mutation.expect.md
@@ -20,9 +20,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     x.push(props.bar);
     props.cond ? ((x = []), x.push(props.foo)) : ((x = []), x.push(props.bar));
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary.expect.md
index 3cfe8d45d5..dc5f680bb3 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-ternary.expect.md
@@ -25,9 +25,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let x;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     x = [];
     x.push(props.bar);
     $[0] = props.bar;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-with-mutation.expect.md
index 2e37ce97fd..3c33ceabab 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-unconditional-with-mutation.expect.md
@@ -26,9 +26,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     x.push(props.bar);
     if (props.cond) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring-with-mutation.expect.md
index f98c37a237..23588488eb 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring-with-mutation.expect.md
@@ -22,9 +22,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     ({ x } = { x: [] });
     x.push(props.bar);
     if (props.cond) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring.expect.md
index 7e012c1b87..b6ad152887 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-via-destructuring.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.bar;
   let x;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     ({ x } = { x: [] });
     x.push(props.bar);
     $[0] = props.bar;
@@ -38,8 +37,7 @@ function foo(props) {
     x = $[1];
   }
   if (props.cond) {
-    const c_2 = $[2] !== props.foo;
-    if (c_2) {
+    if ($[2] !== props.foo) {
       ({ x } = { x: [] });
       x.push(props.foo);
       $[2] = props.foo;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-with-mutation.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-with-mutation.expect.md
index a12689c891..ccec9e88ff 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-with-mutation.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming-with-mutation.expect.md
@@ -22,9 +22,8 @@ function foo(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let x;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     x.push(props.bar);
     if (props.cond) {
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming.expect.md
index d00255849b..a26ab8fea8 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/ssa-renaming.expect.md
@@ -27,9 +27,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function foo(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.bar;
   let x;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     x = [];
     x.push(props.bar);
     $[0] = props.bar;
@@ -38,8 +37,7 @@ function foo(props) {
     x = $[1];
   }
   if (props.cond) {
-    const c_2 = $[2] !== props.foo;
-    if (c_2) {
+    if ($[2] !== props.foo) {
       x = [];
       x.push(props.foo);
       $[2] = props.foo;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
index 27b923b9fd..6b7125dd10 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch-non-final-default.expect.md
@@ -34,10 +34,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(9);
-  const c_0 = $[0] !== props;
   let x;
   let y;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     bb1: switch (props.p0) {
       case 1: {
@@ -68,9 +67,8 @@ function Component(props) {
     x = $[1];
     y = $[2];
   }
-  const c_4 = $[4] !== x;
   let t1;
-  if (c_4) {
+  if ($[4] !== x) {
     t1 = <Component data={x} />;
     $[4] = x;
     $[5] = t1;
@@ -79,10 +77,8 @@ function Component(props) {
   }
   const child = t1;
   y.push(props.p4);
-  const c_6 = $[6] !== y;
-  const c_7 = $[7] !== child;
   let t2;
-  if (c_6 || c_7) {
+  if ($[6] !== y || $[7] !== child) {
     t2 = <Component data={y}>{child}</Component>;
     $[6] = y;
     $[7] = child;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch.expect.md
index b335f0a0bc..d0aa0f09b5 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/switch.expect.md
@@ -29,10 +29,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(8);
-  const c_0 = $[0] !== props;
   let x;
   let y;
-  if (c_0) {
+  if ($[0] !== props) {
     x = [];
     switch (props.p0) {
       case true: {
@@ -50,9 +49,8 @@ function Component(props) {
     x = $[1];
     y = $[2];
   }
-  const c_3 = $[3] !== x;
   let t0;
-  if (c_3) {
+  if ($[3] !== x) {
     t0 = <Component data={x} />;
     $[3] = x;
     $[4] = t0;
@@ -61,10 +59,8 @@ function Component(props) {
   }
   const child = t0;
   y.push(props.p4);
-  const c_5 = $[5] !== y;
-  const c_6 = $[6] !== child;
   let t1;
-  if (c_5 || c_6) {
+  if ($[5] !== y || $[6] !== child) {
     t1 = <Component data={y}>{child}</Component>;
     $[5] = y;
     $[6] = child;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-accessed-outside-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-accessed-outside-scope.expect.md
index eac7cb6158..e181267be2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-accessed-outside-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-accessed-outside-scope.expect.md
@@ -16,10 +16,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props;
   let t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== props) {
     const maybeMutable = new MaybeMutable();
     const x = props;
     t0 = x;
@@ -31,10 +30,8 @@ function Component(props) {
     t0 = $[1];
     t1 = $[2];
   }
-  const c_3 = $[3] !== t0;
-  const c_4 = $[4] !== t1;
   let t2;
-  if (c_3 || c_4) {
+  if ($[3] !== t0 || $[4] !== t1) {
     t2 = [t0, t1];
     $[3] = t0;
     $[4] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-at-start-of-value-block.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-at-start-of-value-block.expect.md
index cbbeb555e9..f433956872 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-at-start-of-value-block.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-at-start-of-value-block.expect.md
@@ -16,9 +16,8 @@ function component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props;
   let t0;
-  if (c_0) {
+  if ($[0] !== props) {
     t0 = isMenuShown ? <Bar> {props.a ? props.b : props.c}</Bar> : null;
     $[0] = props;
     $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-property-load-accessed-outside-scope.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-property-load-accessed-outside-scope.expect.md
index 9b32847042..8ad7ca17e4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-property-load-accessed-outside-scope.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/temporary-property-load-accessed-outside-scope.expect.md
@@ -16,10 +16,9 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(6);
-  const c_0 = $[0] !== props.value;
   let t0;
   let t1;
-  if (c_0) {
+  if ($[0] !== props.value) {
     const maybeMutable = new MaybeMutable();
     const x = props.value;
     t0 = x;
@@ -31,10 +30,8 @@ function Component(props) {
     t0 = $[1];
     t1 = $[2];
   }
-  const c_3 = $[3] !== t0;
-  const c_4 = $[4] !== t1;
   let t2;
-  if (c_3 || c_4) {
+  if ($[3] !== t0 || $[4] !== t1) {
     t2 = [t0, t1];
     $[3] = t0;
     $[4] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo-function-expression-captures-value-later-frozen.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo-function-expression-captures-value-later-frozen.expect.md
index 3e276ce3ee..76f00622a1 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo-function-expression-captures-value-later-frozen.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/todo-function-expression-captures-value-later-frozen.expect.md
@@ -25,9 +25,8 @@ function Component(props) {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.cond;
   let x;
-  if (c_0) {
+  if ($[0] !== props.cond) {
     x = {};
 
     const onChange = (e) => {
@@ -42,9 +41,8 @@ function Component(props) {
   } else {
     x = $[1];
   }
-  const c_2 = $[2] !== x;
   let t0;
-  if (c_2) {
+  if ($[2] !== x) {
     t0 = <Foo value={x} />;
     $[2] = x;
     $[3] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-mutate-outer-value.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-mutate-outer-value.expect.md
index 4c26680cba..a11b9d897a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-mutate-outer-value.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-mutate-outer-value.expect.md
@@ -29,9 +29,8 @@ const { shallowCopy, throwErrorWithMessage } = require("shared-runtime");
 
 function Component(props) {
   const $ = useMemoCache(3);
-  const c_0 = $[0] !== props.a;
   let x;
-  if (c_0) {
+  if ($[0] !== props.a) {
     x = [];
     try {
       let t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch-escaping.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch-escaping.expect.md
index ecb8d24057..60d021ddc2 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch-escaping.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-try-value-modified-in-catch-escaping.expect.md
@@ -33,9 +33,7 @@ const { throwInput } = require("shared-runtime");
 function Component(props) {
   const $ = useMemoCache(3);
   let x;
-  const c_0 = $[0] !== props.y;
-  const c_1 = $[1] !== props.e;
-  if (c_0 || c_1) {
+  if ($[0] !== props.y || $[1] !== props.e) {
     try {
       const y = [];
       y.push(props.y);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
index 531b782f72..410d81bb05 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/try-catch-within-mutable-range.expect.md
@@ -30,9 +30,8 @@ const { throwErrorWithMessage, shallowCopy } = require("shared-runtime");
 
 function Component(props) {
   const $ = useMemoCache(4);
-  const c_0 = $[0] !== props.value;
   let x;
-  if (c_0) {
+  if ($[0] !== props.value) {
     x = [];
     try {
       let t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-cast-expression.flow.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-cast-expression.flow.expect.md
index 7914489fee..e03eb96a3e 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-cast-expression.flow.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/type-cast-expression.flow.expect.md
@@ -26,9 +26,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 type Foo = { bar: string };
 function Component(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.bar;
   let y;
-  if (c_0) {
+  if ($[0] !== props.bar) {
     const x = { bar: props.bar };
     y = (x: Foo);
     y.bar = "hello";
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unary-expr.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unary-expr.expect.md
index 3eefcb3723..d78f4de0de 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unary-expr.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unary-expr.expect.md
@@ -36,15 +36,16 @@ function component(a) {
   const m = !t.t;
   const e = ~t.t;
   const f = typeof t.t;
-  const c_0 = $[0] !== z;
-  const c_1 = $[1] !== p;
-  const c_2 = $[2] !== q;
-  const c_3 = $[3] !== n;
-  const c_4 = $[4] !== m;
-  const c_5 = $[5] !== e;
-  const c_6 = $[6] !== f;
   let t0;
-  if (c_0 || c_1 || c_2 || c_3 || c_4 || c_5 || c_6) {
+  if (
+    $[0] !== z ||
+    $[1] !== p ||
+    $[2] !== q ||
+    $[3] !== n ||
+    $[4] !== m ||
+    $[5] !== e ||
+    $[6] !== f
+  ) {
     t0 = { z, p, q, n, m, e, f };
     $[0] = z;
     $[1] = p;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
index 3d02f9bb35..4ed82d43ae 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/unused-object-element-with-rest.expect.md
@@ -22,9 +22,8 @@ export const FIXTURE_ENTRYPOINT = {
 import { unstable_useMemoCache as useMemoCache } from "react";
 function Foo(props) {
   const $ = useMemoCache(2);
-  const c_0 = $[0] !== props.a;
   let rest;
-  if (c_0) {
+  if ($[0] !== props.a) {
     const { unused, ...t15 } = props.a;
     rest = t15;
     $[0] = props.a;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-in-sequence.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-in-sequence.expect.md
index 55e73ed812..b0abbf4e49 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-in-sequence.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-in-sequence.expect.md
@@ -34,12 +34,8 @@ function Component(props) {
   if (props.cond) {
     d = ((b = a), a++, (c = a), ++a);
   }
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
-  const c_3 = $[3] !== d;
   let t0;
-  if (c_0 || c_1 || c_2 || c_3) {
+  if ($[0] !== a || $[1] !== b || $[2] !== c || $[3] !== d) {
     t0 = [a, b, c, d];
     $[0] = a;
     $[1] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-on-function-parameter.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-on-function-parameter.expect.md
index 062fcad1be..ae3b796e65 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-on-function-parameter.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression-on-function-parameter.expect.md
@@ -35,17 +35,18 @@ function Component(a, t37, t38) {
   const g = --b;
   const h = c++;
   const i = --c;
-  const c_0 = $[0] !== a;
-  const c_1 = $[1] !== b;
-  const c_2 = $[2] !== c;
-  const c_3 = $[3] !== d;
-  const c_4 = $[4] !== e;
-  const c_5 = $[5] !== f;
-  const c_6 = $[6] !== g;
-  const c_7 = $[7] !== h;
-  const c_8 = $[8] !== i;
   let t0;
-  if (c_0 || c_1 || c_2 || c_3 || c_4 || c_5 || c_6 || c_7 || c_8) {
+  if (
+    $[0] !== a ||
+    $[1] !== b ||
+    $[2] !== c ||
+    $[3] !== d ||
+    $[4] !== e ||
+    $[5] !== f ||
+    $[6] !== g ||
+    $[7] !== h ||
+    $[8] !== i
+  ) {
     t0 = [a, b, c, d, e, f, g, h, i];
     $[0] = a;
     $[1] = b;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression.expect.md
index 3afed6867b..d92205796c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/update-expression.expect.md
@@ -26,11 +26,8 @@ function foo(props) {
   let x = props.x;
   const y = x++;
   const z = x--;
-  const c_0 = $[0] !== x;
-  const c_1 = $[1] !== y;
-  const c_2 = $[2] !== z;
   let t0;
-  if (c_0 || c_1 || c_2) {
+  if ($[0] !== x || $[1] !== y || $[2] !== z) {
     t0 = { x, y, z };
     $[0] = x;
     $[1] = y;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/use-callback-simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/use-callback-simple.expect.md
index 2d69ab396f..a0358084e4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/use-callback-simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/use-callback-simple.expect.md
@@ -18,9 +18,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component() {
   const $ = useMemoCache(4);
   const [count, setCount] = useState(0);
-  const c_0 = $[0] !== count;
   let t0;
-  if (c_0) {
+  if ($[0] !== count) {
     t0 = () => setCount(count + 1);
     $[0] = count;
     $[1] = t0;
@@ -28,9 +27,8 @@ function component() {
     t0 = $[1];
   }
   const increment = t0;
-  const c_2 = $[2] !== increment;
   let t1;
-  if (c_2) {
+  if ($[2] !== increment) {
     t1 = <Foo onClick={increment} />;
     $[2] = increment;
     $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-maybe-mutate-context-in-callback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-maybe-mutate-context-in-callback.expect.md
index 3f0fb41929..f7e0ad07dc 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-maybe-mutate-context-in-callback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-maybe-mutate-context-in-callback.expect.md
@@ -39,9 +39,8 @@ const FooContext = React.createContext({ current: null });
 function Component(props) {
   const $ = useMemoCache(5);
   const Foo = useContext(FooContext);
-  const c_0 = $[0] !== Foo.current;
   let t0;
-  if (c_0) {
+  if ($[0] !== Foo.current) {
     t0 = () => {
       mutate(Foo.current);
     };
@@ -51,10 +50,8 @@ function Component(props) {
     t0 = $[1];
   }
   const onClick = t0;
-  const c_2 = $[2] !== onClick;
-  const c_3 = $[3] !== props.children;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== onClick || $[3] !== props.children) {
     t1 = <div onClick={onClick}>{props.children}</div>;
     $[2] = onClick;
     $[3] = props.children;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback-if-condition.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback-if-condition.expect.md
index 4cf8a291e8..6e6faeec3a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback-if-condition.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback-if-condition.expect.md
@@ -42,9 +42,8 @@ const FooContext = createContext({ current: true });
 function Component(props) {
   const $ = useMemoCache(6);
   const foo = useContext(FooContext);
-  const c_0 = $[0] !== foo.current;
   let t0;
-  if (c_0) {
+  if ($[0] !== foo.current) {
     t0 = () => {
       if (foo.current) {
         return {};
@@ -58,9 +57,8 @@ function Component(props) {
     t0 = $[1];
   }
   const getValue = t0;
-  const c_2 = $[2] !== getValue;
   let t1;
-  if (c_2) {
+  if ($[2] !== getValue) {
     t1 = getValue();
     $[2] = getValue;
     $[3] = t1;
@@ -68,9 +66,8 @@ function Component(props) {
     t1 = $[3];
   }
   const value = t1;
-  const c_4 = $[4] !== value;
   let t2;
-  if (c_4) {
+  if ($[4] !== value) {
     t2 = <Child value={value} />;
     $[4] = value;
     $[5] = t2;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback.expect.md
index 6107a03a03..dfb26f2074 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useContext-read-context-in-callback.expect.md
@@ -36,9 +36,8 @@ const FooContext = createContext({ current: null });
 function Component(props) {
   const $ = useMemoCache(5);
   const foo = useContext(FooContext);
-  const c_0 = $[0] !== foo.current;
   let t0;
-  if (c_0) {
+  if ($[0] !== foo.current) {
     t0 = () => {
       console.log(foo.current);
     };
@@ -48,10 +47,8 @@ function Component(props) {
     t0 = $[1];
   }
   const onClick = t0;
-  const c_2 = $[2] !== onClick;
-  const c_3 = $[3] !== props.children;
   let t1;
-  if (c_2 || c_3) {
+  if ($[2] !== onClick || $[3] !== props.children) {
     t1 = <div onClick={onClick}>{props.children}</div>;
     $[2] = onClick;
     $[3] = props.children;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-arg-memoized.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-arg-memoized.expect.md
index a0841bac7b..194efb5d7c 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-arg-memoized.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-arg-memoized.expect.md
@@ -29,9 +29,8 @@ function Component(props) {
   const $ = useMemoCache(6);
   const dispatch = useDispatch();
   useFreeze(dispatch);
-  const c_0 = $[0] !== dispatch;
   let t0;
-  if (c_0) {
+  if ($[0] !== dispatch) {
     t0 = () => {
       dispatch({ kind: "update" });
     };
@@ -41,10 +40,9 @@ function Component(props) {
     t0 = $[1];
   }
   const onUpdate = t0;
-  const c_2 = $[2] !== onUpdate;
   let t1;
   let t2;
-  if (c_2) {
+  if ($[2] !== onUpdate) {
     t1 = () => {
       onUpdate();
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-nested-lambdas.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-nested-lambdas.expect.md
index 5e84d258d5..bff4dcb103 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-nested-lambdas.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useEffect-nested-lambdas.expect.md
@@ -36,9 +36,8 @@ function Component(props) {
   const item = useMutable(props.itemId);
   const dispatch = useDispatch();
   useFreeze(dispatch);
-  const c_0 = $[0] !== dispatch;
   let t0;
-  if (c_0) {
+  if ($[0] !== dispatch) {
     t0 = () => {
       dispatch(createExitAction());
     };
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
index 27ed350587..fc361f4ed4 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-if-else-multiple-return.expect.md
@@ -23,9 +23,8 @@ function Component(props) {
   let t44;
   bb8: {
     if (props.cond) {
-      const c_0 = $[0] !== props.a;
       let t0;
-      if (c_0) {
+      if ($[0] !== props.a) {
         t0 = makeObject(props.a);
         $[0] = props.a;
         $[1] = t0;
@@ -35,9 +34,8 @@ function Component(props) {
       t44 = t0;
       break bb8;
     }
-    const c_2 = $[2] !== props.b;
     let t1;
-    if (c_2) {
+    if ($[2] !== props.b) {
       t1 = makeObject(props.b);
       $[2] = props.b;
       $[3] = t1;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
index d38940f7ea..dc36cd5719 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-independently-memoizeable.expect.md
@@ -21,9 +21,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function Component(props) {
   const $ = useMemoCache(10);
   let t59;
-  const c_0 = $[0] !== props.a;
   let t0;
-  if (c_0) {
+  if ($[0] !== props.a) {
     t0 = makeObject(props.a);
     $[0] = props.a;
     $[1] = t0;
@@ -31,9 +30,8 @@ function Component(props) {
     t0 = $[1];
   }
   const a = t0;
-  const c_2 = $[2] !== props.b;
   let t1;
-  if (c_2) {
+  if ($[2] !== props.b) {
     t1 = makeObject(props.b);
     $[2] = props.b;
     $[3] = t1;
@@ -41,10 +39,8 @@ function Component(props) {
     t1 = $[3];
   }
   const b = t1;
-  const c_4 = $[4] !== a;
-  const c_5 = $[5] !== b;
   let t2;
-  if (c_4 || c_5) {
+  if ($[4] !== a || $[5] !== b) {
     t2 = [a, b];
     $[4] = a;
     $[5] = b;
@@ -54,10 +50,8 @@ function Component(props) {
   }
   t59 = t2;
   const [a_0, b_0] = t59;
-  const c_7 = $[7] !== a_0;
-  const c_8 = $[8] !== b_0;
   let t3;
-  if (c_7 || c_8) {
+  if ($[7] !== a_0 || $[8] !== b_0) {
     t3 = [a_0, b_0];
     $[7] = a_0;
     $[8] = b_0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
index 303f1b6b80..1812c1db9b 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-inlining-block-return.expect.md
@@ -28,9 +28,8 @@ function component(a, b) {
   let t31;
   bb7: {
     if (a) {
-      const c_0 = $[0] !== b;
       let t0;
-      if (c_0) {
+      if ($[0] !== b) {
         t0 = { b };
         $[0] = b;
         $[1] = t0;
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
index 94858838b8..136c29a80a 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-multiple-if-else.expect.md
@@ -35,9 +35,8 @@ function Component(props) {
   const $ = useMemoCache(3);
   let t68;
   bb10: {
-    const c_0 = $[0] !== props;
     let y;
-    if (c_0) {
+    if ($[0] !== props) {
       y = [];
       if (props.cond) {
         y.push(props.a);
diff --git a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
index 4c27031bba..b1709d5d94 100644
--- a/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
+++ b/compiler/packages/babel-plugin-react-forget/src/__tests__/fixtures/compiler/useMemo-simple.expect.md
@@ -16,9 +16,8 @@ import { unstable_useMemoCache as useMemoCache } from "react";
 function component(a) {
   const $ = useMemoCache(4);
   let t24;
-  const c_0 = $[0] !== a;
   let t0;
-  if (c_0) {
+  if ($[0] !== a) {
     t0 = [a];
     $[0] = a;
     $[1] = t0;
@@ -27,9 +26,8 @@ function component(a) {
   }
   t24 = t0;
   const x = t24;
-  const c_2 = $[2] !== x;
   let t1;
-  if (c_2) {
+  if ($[2] !== x) {
     t1 = <Foo x={x} />;
     $[2] = x;
     $[3] = t1;