diff --git a/src/front/glsl/context.rs b/src/front/glsl/context.rs
index c269e5fd18..42866ae5e0 100644
--- a/src/front/glsl/context.rs
+++ b/src/front/glsl/context.rs
@@ -585,6 +585,120 @@ impl Context {
                 self.add_expression(Expression::Constant(constant), meta, body)
             }
             HirExprKind::Binary { left, op, right } if pos != ExprPos::Lhs => {
+                // Logical operators must short circuit by emitting an if statement.
+                // Handle them as a special case.
+                if let BinaryOperator::LogicalAnd | BinaryOperator::LogicalOr = op {
+                    // Lower the lhs, then emit all expressions lowered so far.
+                    let (mut left, left_meta) =
+                        self.lower_expect_inner(stmt, parser, left, ExprPos::Rhs, body)?;
+                    self.emit_restart(body);
+
+                    // Lower the rhs into a special body for use in the if statement.
+                    let mut right_body = Block::new();
+                    let (mut right, right_meta) = self.lower_expect_inner(
+                        stmt,
+                        parser,
+                        right,
+                        ExprPos::Rhs,
+                        &mut right_body,
+                    )?;
+                    self.emit_restart(&mut right_body);
+
+                    // Type check and emit a conversion if necessary.
+                    parser.typifier_grow(self, left, left_meta)?;
+                    parser.typifier_grow(self, right, right_meta)?;
+                    self.binary_implicit_conversion(
+                        parser, &mut left, left_meta, &mut right, right_meta,
+                    )?;
+                    self.emit_end(body);
+
+                    // Create a temporary local to hold the result of the operator.
+                    let bool_ty = parser.module.types.insert(
+                        Type {
+                            name: None,
+                            inner: TypeInner::Scalar {
+                                kind: ScalarKind::Bool,
+                                width: crate::BOOL_WIDTH,
+                            },
+                        },
+                        Default::default(),
+                    );
+                    let local = self.locals.append(
+                        LocalVariable {
+                            name: None,
+                            ty: bool_ty,
+                            init: None,
+                        },
+                        meta,
+                    );
+                    let local_expr = self
+                        .expressions
+                        .append(Expression::LocalVariable(local), meta);
+
+                    // Store the result of the RHS to the local.
+                    right_body.push(
+                        Statement::Store {
+                            pointer: local_expr,
+                            value: right,
+                        },
+                        right_meta,
+                    );
+
+                    // Create a value representing the result of the operator if it short circuits and does not evaluate the RHS.
+                    let short_circuit_value = match op {
+                        BinaryOperator::LogicalAnd => false,
+                        BinaryOperator::LogicalOr => true,
+                        _ => unreachable!(),
+                    };
+                    let short_circuit_constant = parser.module.constants.fetch_or_append(
+                        Constant {
+                            name: None,
+                            specialization: None,
+                            inner: crate::ConstantInner::boolean(short_circuit_value),
+                        },
+                        Default::default(),
+                    );
+                    let short_circuit_expr = self
+                        .expressions
+                        .append(Expression::Constant(short_circuit_constant), meta);
+
+                    // Create a short circuit body, which assigns the short circuit value to the local.
+                    let mut short_circuit_body = Block::new();
+                    short_circuit_body.push(
+                        Statement::Store {
+                            pointer: local_expr,
+                            value: short_circuit_expr,
+                        },
+                        meta,
+                    );
+
+                    // Add an if statement which either evaluates the RHS block or the short circuit block.
+                    let (accept, reject) = match op {
+                        BinaryOperator::LogicalAnd => (right_body, short_circuit_body),
+                        BinaryOperator::LogicalOr => (short_circuit_body, right_body),
+                        _ => unimplemented!(),
+                    };
+                    body.push(
+                        Statement::If {
+                            condition: left,
+                            accept,
+                            reject,
+                        },
+                        meta,
+                    );
+
+                    // The result of lowering this operator is just the local in which the result is stored.
+                    self.emit_start();
+                    let load_local_expr = self.expressions.append(
+                        Expression::Load {
+                            pointer: local_expr,
+                        },
+                        meta,
+                    );
+
+                    return Ok((Some(load_local_expr), meta));
+                };
+
                 let (mut left, left_meta) =
                     self.lower_expect_inner(stmt, parser, left, ExprPos::Rhs, body)?;
                 let (mut right, right_meta) =
diff --git a/src/front/wgsl/mod.rs b/src/front/wgsl/mod.rs
index 2732c5b572..4671f9d736 100644
--- a/src/front/wgsl/mod.rs
+++ b/src/front/wgsl/mod.rs
@@ -813,7 +813,7 @@ struct ExpressionContext<'input, 'temp, 'out> {
     types: &'out mut UniqueArena<crate::Type>,
     constants: &'out mut Arena<crate::Constant>,
     global_vars: &'out Arena<crate::GlobalVariable>,
-    local_vars: &'out Arena<crate::LocalVariable>,
+    local_vars: &'out mut Arena<crate::LocalVariable>,
     arguments: &'out [crate::FunctionArgument],
     functions: &'out Arena<crate::Function>,
     block: &'temp mut crate::Block,
@@ -897,6 +897,124 @@ impl<'a> ExpressionContext<'a, '_, '_> {
         Ok(accumulator)
     }
 
+    fn parse_binary_short_circuit_op(
+        &mut self,
+        lexer: &mut Lexer<'a>,
+        classifier: impl Fn(Token<'a>) -> Option<crate::BinaryOperator>,
+        mut parser: impl FnMut(
+            &mut Lexer<'a>,
+            ExpressionContext<'a, '_, '_>,
+        ) -> Result<TypedExpression, Error<'a>>,
+    ) -> Result<TypedExpression, Error<'a>> {
+        let start = lexer.current_byte_offset() as u32;
+        let mut accumulator = parser(lexer, self.reborrow())?;
+        while let Some(op) = classifier(lexer.peek().0) {
+            let _ = lexer.next();
+
+            // Apply load rule to the lhs.
+            let left = self.apply_load_rule(accumulator);
+
+            // Emit all previous expressions, and prepare a body for the rhs.
+            self.block.extend(self.emitter.finish(self.expressions));
+            let mut rhs_body = crate::Block::new();
+            let mut rhs_ctx = self.reborrow();
+            rhs_ctx.block = &mut rhs_body;
+            rhs_ctx.emitter.start(rhs_ctx.expressions);
+
+            // Parse the rhs using the rhs body.
+            let unloaded_right = parser(lexer, rhs_ctx)?;
+            let end = lexer.current_byte_offset() as u32;
+            let span = NagaSpan::new(start, end);
+            let right = self.apply_load_rule(unloaded_right);
+            rhs_body.extend(self.emitter.finish(self.expressions));
+
+            // Create a temporary local to store the result of the operator.
+            let local_ty = self.types.insert(
+                crate::Type {
+                    name: None,
+                    inner: crate::TypeInner::Scalar {
+                        kind: crate::ScalarKind::Bool,
+                        width: crate::BOOL_WIDTH,
+                    },
+                },
+                Default::default(),
+            );
+            let local = self.local_vars.append(
+                crate::LocalVariable {
+                    name: None,
+                    ty: local_ty,
+                    init: None,
+                },
+                span,
+            );
+
+            // Assign the rhs expression to the local variable inside the rhs body.
+            let local_expr = self
+                .expressions
+                .append(crate::Expression::LocalVariable(local), span);
+
+            rhs_body.push(
+                crate::Statement::Store {
+                    pointer: local_expr,
+                    value: right,
+                },
+                span,
+            );
+
+            // Make a short circuit body which assigns the local variable to the short circuit value.
+            let short_circuit_value = match op {
+                crate::BinaryOperator::LogicalAnd => false,
+                crate::BinaryOperator::LogicalOr => true,
+                _ => unreachable!(),
+            };
+
+            let short_circuit_constant = self.constants.fetch_or_append(
+                crate::Constant {
+                    name: None,
+                    specialization: None,
+                    inner: ConstantInner::boolean(short_circuit_value),
+                },
+                Default::default(),
+            );
+            let short_circuit_expr = self
+                .expressions
+                .append(crate::Expression::Constant(short_circuit_constant), span);
+
+            let mut short_circuit_body = crate::Block::new();
+            short_circuit_body.push(
+                crate::Statement::Store {
+                    pointer: local_expr,
+                    value: short_circuit_expr,
+                },
+                span,
+            );
+
+            // Append an if statement. This implements the short circuiting behavior, by deciding whether to
+            // evaluate the rhs based on the value of the lhs.
+            let (accept, reject) = match op {
+                crate::BinaryOperator::LogicalAnd => (rhs_body, short_circuit_body),
+                crate::BinaryOperator::LogicalOr => (short_circuit_body, rhs_body),
+                _ => unreachable!(),
+            };
+            self.block.push(
+                crate::Statement::If {
+                    condition: left,
+                    accept,
+                    reject,
+                },
+                span,
+            );
+
+            // Prepare to resume parsing expressions.
+            self.emitter.start(self.expressions);
+            accumulator = TypedExpression {
+                handle: local_expr,
+                is_reference: true,
+            };
+        }
+        Ok(accumulator)
+    }
+
     fn parse_binary_splat_op(
         &mut self,
         lexer: &mut Lexer<'a>,
@@ -2683,7 +2801,7 @@ impl Parser {
     ) -> Result<(TypedExpression, Span), Error<'a>> {
         self.push_scope(Scope::GeneralExpr, lexer);
         // logical_or_expression
-        let handle = context.parse_binary_op(
+        let handle = context.parse_binary_short_circuit_op(
             lexer,
             |token| match token {
                 Token::LogicalOperation('|') => Some(crate::BinaryOperator::LogicalOr),
@@ -2691,7 +2809,7 @@ impl Parser {
             },
             // logical_and_expression
             |lexer, mut context| {
-                context.parse_binary_op(
+                context.parse_binary_short_circuit_op(
                     lexer,
                     |token| match token {
                         Token::LogicalOperation('&') => Some(crate::BinaryOperator::LogicalAnd),
diff --git a/tests/in/glsl/short_circuit.frag b/tests/in/glsl/short_circuit.frag
new file mode 100644
index 0000000000..279776f323
--- /dev/null
+++ b/tests/in/glsl/short_circuit.frag
@@ -0,0 +1,12 @@
+#version 460 core
+
+bool a() { return true; }
+bool b() { return true; }
+bool c() { return true; }
+bool d() { return true; }
+
+void main() {
+    bool out1 = a() || b() || c();
+    bool out2 = a() && b() && c();
+    bool out3 = (a() || b()) && (c() || d());
+}
diff --git a/tests/in/short_circuit.param.ron b/tests/in/short_circuit.param.ron
new file mode 100644
index 0000000000..72873dd667
--- /dev/null
+++ b/tests/in/short_circuit.param.ron
@@ -0,0 +1,2 @@
+(
+)
diff --git a/tests/in/short_circuit.wgsl b/tests/in/short_circuit.wgsl
new file mode 100644
index 0000000000..bc7d031bf0
--- /dev/null
+++ b/tests/in/short_circuit.wgsl
@@ -0,0 +1,11 @@
+fn a() -> bool { return true; }
+fn b() -> bool { return true; }
+fn c() -> bool { return true; }
+fn d() -> bool { return true; }
+
+@compute @workgroup_size(1)
+fn main() {
+    _ = a() || b() || c();
+    _ = a() && b() && c();
+    _ = (a() || b()) && (c() || d());
+}
diff --git a/tests/out/glsl/operators.main.Compute.glsl b/tests/out/glsl/operators.main.Compute.glsl
index ab232d5532..2f5b7ebb7d 100644
--- a/tests/out/glsl/operators.main.Compute.glsl
+++ b/tests/out/glsl/operators.main.Compute.glsl
@@ -54,10 +54,22 @@ float constructors() {
 }
 
 void logical() {
+    bool local = false;
+    bool local_1 = false;
     bool unnamed_11 = (!true);
     bvec2 unnamed_12 = not(bvec2(true));
-    bool unnamed_13 = (true || false);
-    bool unnamed_14 = (true && false);
+    if (true) {
+        local = true;
+    } else {
+        local = false;
+    }
+    bool unnamed_13 = local;
+    if (true) {
+        local_1 = false;
+    } else {
+        local_1 = false;
+    }
+    bool unnamed_14 = local_1;
     bool unnamed_15 = (true || false);
     bvec3 unnamed_16 = bvec3(bvec3(true).x || bvec3(false).x, bvec3(true).y || bvec3(false).y, bvec3(true).z || bvec3(false).z);
     bool unnamed_17 = (true && false);
diff --git a/tests/out/glsl/short_circuit.main.Compute.glsl b/tests/out/glsl/short_circuit.main.Compute.glsl
new file mode 100644
index 0000000000..b759f2bb32
--- /dev/null
+++ b/tests/out/glsl/short_circuit.main.Compute.glsl
@@ -0,0 +1,86 @@
+#version 310 es
+
+precision highp float;
+precision highp int;
+
+layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;
+
+
+bool a() {
+    return true;
+}
+
+bool b() {
+    return true;
+}
+
+bool c() {
+    return true;
+}
+
+bool d() {
+    return true;
+}
+
+void main() {
+    bool local = false;
+    bool local_1 = false;
+    bool local_2 = false;
+    bool local_3 = false;
+    bool local_4 = false;
+    bool local_5 = false;
+    bool local_6 = false;
+    bool _e0 = a();
+    if (_e0) {
+        local = true;
+    } else {
+        bool _e1 = b();
+        local = _e1;
+    }
+    bool _e4 = local;
+    if (_e4) {
+        local_1 = true;
+    } else {
+        bool _e5 = c();
+        local_1 = _e5;
+    }
+    bool unnamed = local_1;
+    bool _e9 = a();
+    if (_e9) {
+        bool _e10 = b();
+        local_2 = _e10;
+    } else {
+        local_2 = false;
+    }
+    bool _e13 = local_2;
+    if (_e13) {
+        bool _e14 = c();
+        local_3 = _e14;
+    } else {
+        local_3 = false;
+    }
+    bool unnamed_1 = local_3;
+    bool _e18 = a();
+    if (_e18) {
+        local_4 = true;
+    } else {
+        bool _e19 = b();
+        local_4 = _e19;
+    }
+    bool _e22 = local_4;
+    if (_e22) {
+        bool _e23 = c();
+        if (_e23) {
+            local_5 = true;
+        } else {
+            bool _e24 = d();
+            local_5 = _e24;
+        }
+        bool _e27 = local_5;
+        local_6 = _e27;
+    } else {
+        local_6 = false;
+    }
+    bool unnamed_2 = local_6;
+}
+
diff --git a/tests/out/hlsl/operators.hlsl b/tests/out/hlsl/operators.hlsl
index 01ffb90360..2bc92e330b 100644
--- a/tests/out/hlsl/operators.hlsl
+++ b/tests/out/hlsl/operators.hlsl
@@ -80,10 +80,23 @@ float constructors()
 
 void logical()
 {
+    bool local = (bool)0;
+    bool local_1 = (bool)0;
+
     bool unnamed_11 = !true;
     bool2 unnamed_12 = !(true).xx;
-    bool unnamed_13 = (true || false);
-    bool unnamed_14 = (true && false);
+    if (true) {
+        local = true;
+    } else {
+        local = false;
+    }
+    bool unnamed_13 = local;
+    if (true) {
+        local_1 = false;
+    } else {
+        local_1 = false;
+    }
+    bool unnamed_14 = local_1;
     bool unnamed_15 = (true | false);
     bool3 unnamed_16 = ((true).xxx | (false).xxx);
     bool unnamed_17 = (true & false);
diff --git a/tests/out/hlsl/short_circuit.hlsl b/tests/out/hlsl/short_circuit.hlsl
new file mode 100644
index 0000000000..59f941852f
--- /dev/null
+++ b/tests/out/hlsl/short_circuit.hlsl
@@ -0,0 +1,85 @@
+
+bool a()
+{
+    return true;
+}
+
+bool b()
+{
+    return true;
+}
+
+bool c()
+{
+    return true;
+}
+
+bool d()
+{
+    return true;
+}
+
+[numthreads(1, 1, 1)]
+void main()
+{
+    bool local = (bool)0;
+    bool local_1 = (bool)0;
+    bool local_2 = (bool)0;
+    bool local_3 = (bool)0;
+    bool local_4 = (bool)0;
+    bool local_5 = (bool)0;
+    bool local_6 = (bool)0;
+
+    const bool _e0 = a();
+    if (_e0) {
+        local = true;
+    } else {
+        const bool _e1 = b();
+        local = _e1;
+    }
+    bool _expr4 = local;
+    if (_expr4) {
+        local_1 = true;
+    } else {
+        const bool _e5 = c();
+        local_1 = _e5;
+    }
+    bool unnamed = local_1;
+    const bool _e9 = a();
+    if (_e9) {
+        const bool _e10 = b();
+        local_2 = _e10;
+    } else {
+        local_2 = false;
+    }
+    bool _expr13 = local_2;
+    if (_expr13) {
+        const bool _e14 = c();
+        local_3 = _e14;
+    } else {
+        local_3 = false;
+    }
+    bool unnamed_1 = local_3;
+    const bool _e18 = a();
+    if (_e18) {
+        local_4 = true;
+    } else {
+        const bool _e19 = b();
+        local_4 = _e19;
+    }
+    bool _expr22 = local_4;
+    if (_expr22) {
+        const bool _e23 = c();
+        if (_e23) {
+            local_5 = true;
+        } else {
+            const bool _e24 = d();
+            local_5 = _e24;
+        }
+        bool _expr27 = local_5;
+        local_6 = _expr27;
+    } else {
+        local_6 = false;
+    }
+    bool unnamed_2 = local_6;
+}
diff --git a/tests/out/hlsl/short_circuit.hlsl.config b/tests/out/hlsl/short_circuit.hlsl.config
new file mode 100644
index 0000000000..246c485cf7
--- /dev/null
+++ b/tests/out/hlsl/short_circuit.hlsl.config
@@ -0,0 +1,3 @@
+vertex=()
+fragment=()
+compute=(main:cs_5_1 )
diff --git a/tests/out/msl/operators.msl b/tests/out/msl/operators.msl
index 294fa58125..f1b0e960aa 100644
--- a/tests/out/msl/operators.msl
+++ b/tests/out/msl/operators.msl
@@ -81,10 +81,22 @@ float constructors(
 
 void logical(
 ) {
+    bool local = {};
+    bool local_1 = {};
     bool unnamed_11 = !true;
     metal::bool2 unnamed_12 = !metal::bool2(true);
-    bool unnamed_13 = true || false;
-    bool unnamed_14 = true && false;
+    if (true) {
+        local = true;
+    } else {
+        local = false;
+    }
+    bool unnamed_13 = local;
+    if (true) {
+        local_1 = false;
+    } else {
+        local_1 = false;
+    }
+    bool unnamed_14 = local_1;
     bool unnamed_15 = true | false;
     metal::bool3 unnamed_16 = metal::bool3(true) | metal::bool3(false);
     bool unnamed_17 = true & false;
diff --git a/tests/out/msl/short_circuit.msl b/tests/out/msl/short_circuit.msl
new file mode 100644
index 0000000000..ce45d8467c
--- /dev/null
+++ b/tests/out/msl/short_circuit.msl
@@ -0,0 +1,89 @@
+// language: metal2.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+
+bool a(
+) {
+    return true;
+}
+
+bool b(
+) {
+    return true;
+}
+
+bool c(
+) {
+    return true;
+}
+
+bool d(
+) {
+    return true;
+}
+
+kernel void main_(
+) {
+    bool local = {};
+    bool local_1 = {};
+    bool local_2 = {};
+    bool local_3 = {};
+    bool local_4 = {};
+    bool local_5 = {};
+    bool local_6 = {};
+    bool _e0 = a();
+    if (_e0) {
+        local = true;
+    } else {
+        bool _e1 = b();
+        local = _e1;
+    }
+    bool _e4 = local;
+    if (_e4) {
+        local_1 = true;
+    } else {
+        bool _e5 = c();
+        local_1 = _e5;
+    }
+    bool unnamed = local_1;
+    bool _e9 = a();
+    if (_e9) {
+        bool _e10 = b();
+        local_2 = _e10;
+    } else {
+        local_2 = false;
+    }
+    bool _e13 = local_2;
+    if (_e13) {
+        bool _e14 = c();
+        local_3 = _e14;
+    } else {
+        local_3 = false;
+    }
+    bool unnamed_1 = local_3;
+    bool _e18 = a();
+    if (_e18) {
+        local_4 = true;
+    } else {
+        bool _e19 = b();
+        local_4 = _e19;
+    }
+    bool _e22 = local_4;
+    if (_e22) {
+        bool _e23 = c();
+        if (_e23) {
+            local_5 = true;
+        } else {
+            bool _e24 = d();
+            local_5 = _e24;
+        }
+        bool _e27 = local_5;
+        local_6 = _e27;
+    } else {
+        local_6 = false;
+    }
+    bool unnamed_2 = local_6;
+}
diff --git a/tests/out/spv/operators.spvasm b/tests/out/spv/operators.spvasm
index 2e7cc31391..c90ae4350e 100644
--- a/tests/out/spv/operators.spvasm
+++ b/tests/out/spv/operators.spvasm
@@ -1,12 +1,12 @@
 ; SPIR-V
 ; Version: 1.1
 ; Generator: rspirv
-; Bound: 525
+; Bound: 536
 OpCapability Shader
 %1 = OpExtInstImport "GLSL.std.450"
 OpMemoryModel Logical GLSL450
-OpEntryPoint GLCompute %513 "main"
-OpExecutionMode %513 LocalSize 1 1 1
+OpEntryPoint GLCompute %524 "main"
+OpExecutionMode %524 LocalSize 1 1 1
 OpMemberDecorate %30 0 Offset 0
 OpMemberDecorate %30 1 Offset 16
 OpDecorate %35 ArrayStride 32
@@ -75,13 +75,16 @@ OpDecorate %36 ArrayStride 4
 %115 = OpTypeFunction %4
 %140 = OpTypePointer Function %26
 %141 = OpTypePointer Function %4
-%146 = OpTypeFunction %2
-%149 = OpTypeVector %10 2
-%165 = OpTypeVector %8 2
-%176 = OpTypeVector %20 3
-%471 = OpTypePointer Function %8
-%473 = OpTypePointer Function %41
-%503 = OpTypePointer Function %8
+%145 = OpTypePointer Function %10
+%146 = OpConstantNull  %10
+%148 = OpConstantNull  %10
+%151 = OpTypeFunction %2
+%154 = OpTypeVector %10 2
+%176 = OpTypeVector %8 2
+%187 = OpTypeVector %20 3
+%482 = OpTypePointer Function %8
+%484 = OpTypePointer Function %41
+%514 = OpTypePointer Function %8
 %59 = OpFunction  %26  None %60
 %58 = OpLabel
 OpBranch %61
@@ -173,409 +176,429 @@ OpStore %110 %118
 %143 = OpLoad  %4  %142
 OpReturnValue %143
 OpFunctionEnd
-%145 = OpFunction  %2  None %146
-%144 = OpLabel
-OpBranch %147
-%147 = OpLabel
-%148 = OpLogicalNot  %10  %9
-%150 = OpCompositeConstruct  %149  %9 %9
-%151 = OpLogicalNot  %149  %150
-%152 = OpLogicalOr  %10  %9 %12
-%153 = OpLogicalAnd  %10  %9 %12
-%154 = OpLogicalOr  %10  %9 %12
-%155 = OpCompositeConstruct  %104  %9 %9 %9
-%156 = OpCompositeConstruct  %104  %12 %12 %12
-%157 = OpLogicalOr  %104  %155 %156
-%158 = OpLogicalAnd  %10  %9 %12
-%159 = OpCompositeConstruct  %28  %9 %9 %9 %9
-%160 = OpCompositeConstruct  %28  %12 %12 %12 %12
-%161 = OpLogicalAnd  %28  %159 %160
+%150 = OpFunction  %2  None %151
+%149 = OpLabel
+%144 = OpVariable  %145  Function %146
+%147 = OpVariable  %145  Function %148
+OpBranch %152
+%152 = OpLabel
+%153 = OpLogicalNot  %10  %9
+%155 = OpCompositeConstruct  %154  %9 %9
+%156 = OpLogicalNot  %154  %155
+OpSelectionMerge %157 None
+OpBranchConditional %9 %158 %159
+%158 = OpLabel
+OpStore %144 %9
+OpBranch %157
+%159 = OpLabel
+OpStore %144 %12
+OpBranch %157
+%157 = OpLabel
+%160 = OpLoad  %10  %144
+OpSelectionMerge %161 None
+OpBranchConditional %9 %162 %163
+%162 = OpLabel
+OpStore %147 %12
+OpBranch %161
+%163 = OpLabel
+OpStore %147 %12
+OpBranch %161
+%161 = OpLabel
+%164 = OpLoad  %10  %147
+%165 = OpLogicalOr  %10  %9 %12
+%166 = OpCompositeConstruct  %104  %9 %9 %9
+%167 = OpCompositeConstruct  %104  %12 %12 %12
+%168 = OpLogicalOr  %104  %166 %167
+%169 = OpLogicalAnd  %10  %9 %12
+%170 = OpCompositeConstruct  %28  %9 %9 %9 %9
+%171 = OpCompositeConstruct  %28  %12 %12 %12 %12
+%172 = OpLogicalAnd  %28  %170 %171
 OpReturn
 OpFunctionEnd
-%163 = OpFunction  %2  None %146
-%162 = OpLabel
-OpBranch %164
-%164 = OpLabel
-%166 = OpCompositeConstruct  %165  %7 %7
-%167 = OpSNegate  %165  %166
-%168 = OpCompositeConstruct  %31  %3 %3
-%169 = OpFNegate  %31  %168
-%170 = OpIAdd  %8  %18 %7
-%171 = OpIAdd  %20  %24 %25
-%172 = OpFAdd  %4  %14 %3
-%173 = OpCompositeConstruct  %165  %18 %18
-%174 = OpCompositeConstruct  %165  %7 %7
-%175 = OpIAdd  %165  %173 %174
-%177 = OpCompositeConstruct  %176  %24 %24 %24
-%178 = OpCompositeConstruct  %176  %25 %25 %25
-%179 = OpIAdd  %176  %177 %178
-%180 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%181 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%182 = OpFAdd  %26  %180 %181
-%183 = OpISub  %8  %18 %7
-%184 = OpISub  %20  %24 %25
-%185 = OpFSub  %4  %14 %3
-%186 = OpCompositeConstruct  %165  %18 %18
-%187 = OpCompositeConstruct  %165  %7 %7
-%188 = OpISub  %165  %186 %187
-%189 = OpCompositeConstruct  %176  %24 %24 %24
-%190 = OpCompositeConstruct  %176  %25 %25 %25
-%191 = OpISub  %176  %189 %190
-%192 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%193 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%194 = OpFSub  %26  %192 %193
-%195 = OpIMul  %8  %18 %7
-%196 = OpIMul  %20  %24 %25
-%197 = OpFMul  %4  %14 %3
-%198 = OpCompositeConstruct  %165  %18 %18
-%199 = OpCompositeConstruct  %165  %7 %7
-%200 = OpIMul  %165  %198 %199
-%201 = OpCompositeConstruct  %176  %24 %24 %24
-%202 = OpCompositeConstruct  %176  %25 %25 %25
-%203 = OpIMul  %176  %201 %202
-%204 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%205 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%206 = OpFMul  %26  %204 %205
-%207 = OpSDiv  %8  %18 %7
-%208 = OpUDiv  %20  %24 %25
-%209 = OpFDiv  %4  %14 %3
-%210 = OpCompositeConstruct  %165  %18 %18
-%211 = OpCompositeConstruct  %165  %7 %7
-%212 = OpSDiv  %165  %210 %211
-%213 = OpCompositeConstruct  %176  %24 %24 %24
-%214 = OpCompositeConstruct  %176  %25 %25 %25
-%215 = OpUDiv  %176  %213 %214
-%216 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%217 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%218 = OpFDiv  %26  %216 %217
-%219 = OpSRem  %8  %18 %7
-%220 = OpUMod  %20  %24 %25
-%221 = OpFRem  %4  %14 %3
-%222 = OpCompositeConstruct  %165  %18 %18
-%223 = OpCompositeConstruct  %165  %7 %7
-%224 = OpSRem  %165  %222 %223
-%225 = OpCompositeConstruct  %176  %24 %24 %24
-%226 = OpCompositeConstruct  %176  %25 %25 %25
-%227 = OpUMod  %176  %225 %226
-%228 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%229 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%230 = OpFRem  %26  %228 %229
-%231 = OpCompositeConstruct  %165  %18 %18
-%232 = OpCompositeConstruct  %165  %7 %7
-%233 = OpIAdd  %165  %231 %232
-%234 = OpCompositeConstruct  %165  %7 %7
-%235 = OpCompositeConstruct  %165  %18 %18
-%236 = OpIAdd  %165  %235 %234
-%237 = OpCompositeConstruct  %34  %24 %24
-%238 = OpCompositeConstruct  %34  %25 %25
-%239 = OpIAdd  %34  %237 %238
-%240 = OpCompositeConstruct  %34  %25 %25
-%241 = OpCompositeConstruct  %34  %24 %24
-%242 = OpIAdd  %34  %241 %240
-%243 = OpCompositeConstruct  %31  %14 %14
-%244 = OpCompositeConstruct  %31  %3 %3
-%245 = OpFAdd  %31  %243 %244
-%246 = OpCompositeConstruct  %31  %3 %3
-%247 = OpCompositeConstruct  %31  %14 %14
-%248 = OpFAdd  %31  %247 %246
-%249 = OpCompositeConstruct  %165  %18 %18
-%250 = OpCompositeConstruct  %165  %7 %7
-%251 = OpISub  %165  %249 %250
-%252 = OpCompositeConstruct  %165  %7 %7
-%253 = OpCompositeConstruct  %165  %18 %18
-%254 = OpISub  %165  %253 %252
-%255 = OpCompositeConstruct  %34  %24 %24
-%256 = OpCompositeConstruct  %34  %25 %25
-%257 = OpISub  %34  %255 %256
-%258 = OpCompositeConstruct  %34  %25 %25
-%259 = OpCompositeConstruct  %34  %24 %24
-%260 = OpISub  %34  %259 %258
-%261 = OpCompositeConstruct  %31  %14 %14
-%262 = OpCompositeConstruct  %31  %3 %3
-%263 = OpFSub  %31  %261 %262
-%264 = OpCompositeConstruct  %31  %3 %3
-%265 = OpCompositeConstruct  %31  %14 %14
-%266 = OpFSub  %31  %265 %264
-%267 = OpCompositeConstruct  %165  %18 %18
-%269 = OpCompositeConstruct  %165  %7 %7
-%268 = OpIMul  %165  %267 %269
-%270 = OpCompositeConstruct  %165  %7 %7
-%272 = OpCompositeConstruct  %165  %18 %18
-%271 = OpIMul  %165  %270 %272
-%273 = OpCompositeConstruct  %34  %24 %24
-%275 = OpCompositeConstruct  %34  %25 %25
-%274 = OpIMul  %34  %273 %275
-%276 = OpCompositeConstruct  %34  %25 %25
-%278 = OpCompositeConstruct  %34  %24 %24
-%277 = OpIMul  %34  %276 %278
-%279 = OpCompositeConstruct  %31  %14 %14
-%280 = OpVectorTimesScalar  %31  %279 %3
-%281 = OpCompositeConstruct  %31  %3 %3
-%282 = OpVectorTimesScalar  %31  %281 %14
-%283 = OpCompositeConstruct  %165  %18 %18
-%284 = OpCompositeConstruct  %165  %7 %7
-%285 = OpSDiv  %165  %283 %284
-%286 = OpCompositeConstruct  %165  %7 %7
-%287 = OpCompositeConstruct  %165  %18 %18
-%288 = OpSDiv  %165  %287 %286
+%174 = OpFunction  %2  None %151
+%173 = OpLabel
+OpBranch %175
+%175 = OpLabel
+%177 = OpCompositeConstruct  %176  %7 %7
+%178 = OpSNegate  %176  %177
+%179 = OpCompositeConstruct  %31  %3 %3
+%180 = OpFNegate  %31  %179
+%181 = OpIAdd  %8  %18 %7
+%182 = OpIAdd  %20  %24 %25
+%183 = OpFAdd  %4  %14 %3
+%184 = OpCompositeConstruct  %176  %18 %18
+%185 = OpCompositeConstruct  %176  %7 %7
+%186 = OpIAdd  %176  %184 %185
+%188 = OpCompositeConstruct  %187  %24 %24 %24
+%189 = OpCompositeConstruct  %187  %25 %25 %25
+%190 = OpIAdd  %187  %188 %189
+%191 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%192 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%193 = OpFAdd  %26  %191 %192
+%194 = OpISub  %8  %18 %7
+%195 = OpISub  %20  %24 %25
+%196 = OpFSub  %4  %14 %3
+%197 = OpCompositeConstruct  %176  %18 %18
+%198 = OpCompositeConstruct  %176  %7 %7
+%199 = OpISub  %176  %197 %198
+%200 = OpCompositeConstruct  %187  %24 %24 %24
+%201 = OpCompositeConstruct  %187  %25 %25 %25
+%202 = OpISub  %187  %200 %201
+%203 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%204 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%205 = OpFSub  %26  %203 %204
+%206 = OpIMul  %8  %18 %7
+%207 = OpIMul  %20  %24 %25
+%208 = OpFMul  %4  %14 %3
+%209 = OpCompositeConstruct  %176  %18 %18
+%210 = OpCompositeConstruct  %176  %7 %7
+%211 = OpIMul  %176  %209 %210
+%212 = OpCompositeConstruct  %187  %24 %24 %24
+%213 = OpCompositeConstruct  %187  %25 %25 %25
+%214 = OpIMul  %187  %212 %213
+%215 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%216 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%217 = OpFMul  %26  %215 %216
+%218 = OpSDiv  %8  %18 %7
+%219 = OpUDiv  %20  %24 %25
+%220 = OpFDiv  %4  %14 %3
+%221 = OpCompositeConstruct  %176  %18 %18
+%222 = OpCompositeConstruct  %176  %7 %7
+%223 = OpSDiv  %176  %221 %222
+%224 = OpCompositeConstruct  %187  %24 %24 %24
+%225 = OpCompositeConstruct  %187  %25 %25 %25
+%226 = OpUDiv  %187  %224 %225
+%227 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%228 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%229 = OpFDiv  %26  %227 %228
+%230 = OpSRem  %8  %18 %7
+%231 = OpUMod  %20  %24 %25
+%232 = OpFRem  %4  %14 %3
+%233 = OpCompositeConstruct  %176  %18 %18
+%234 = OpCompositeConstruct  %176  %7 %7
+%235 = OpSRem  %176  %233 %234
+%236 = OpCompositeConstruct  %187  %24 %24 %24
+%237 = OpCompositeConstruct  %187  %25 %25 %25
+%238 = OpUMod  %187  %236 %237
+%239 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%240 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%241 = OpFRem  %26  %239 %240
+%242 = OpCompositeConstruct  %176  %18 %18
+%243 = OpCompositeConstruct  %176  %7 %7
+%244 = OpIAdd  %176  %242 %243
+%245 = OpCompositeConstruct  %176  %7 %7
+%246 = OpCompositeConstruct  %176  %18 %18
+%247 = OpIAdd  %176  %246 %245
+%248 = OpCompositeConstruct  %34  %24 %24
+%249 = OpCompositeConstruct  %34  %25 %25
+%250 = OpIAdd  %34  %248 %249
+%251 = OpCompositeConstruct  %34  %25 %25
+%252 = OpCompositeConstruct  %34  %24 %24
+%253 = OpIAdd  %34  %252 %251
+%254 = OpCompositeConstruct  %31  %14 %14
+%255 = OpCompositeConstruct  %31  %3 %3
+%256 = OpFAdd  %31  %254 %255
+%257 = OpCompositeConstruct  %31  %3 %3
+%258 = OpCompositeConstruct  %31  %14 %14
+%259 = OpFAdd  %31  %258 %257
+%260 = OpCompositeConstruct  %176  %18 %18
+%261 = OpCompositeConstruct  %176  %7 %7
+%262 = OpISub  %176  %260 %261
+%263 = OpCompositeConstruct  %176  %7 %7
+%264 = OpCompositeConstruct  %176  %18 %18
+%265 = OpISub  %176  %264 %263
+%266 = OpCompositeConstruct  %34  %24 %24
+%267 = OpCompositeConstruct  %34  %25 %25
+%268 = OpISub  %34  %266 %267
+%269 = OpCompositeConstruct  %34  %25 %25
+%270 = OpCompositeConstruct  %34  %24 %24
+%271 = OpISub  %34  %270 %269
+%272 = OpCompositeConstruct  %31  %14 %14
+%273 = OpCompositeConstruct  %31  %3 %3
+%274 = OpFSub  %31  %272 %273
+%275 = OpCompositeConstruct  %31  %3 %3
+%276 = OpCompositeConstruct  %31  %14 %14
+%277 = OpFSub  %31  %276 %275
+%278 = OpCompositeConstruct  %176  %18 %18
+%280 = OpCompositeConstruct  %176  %7 %7
+%279 = OpIMul  %176  %278 %280
+%281 = OpCompositeConstruct  %176  %7 %7
+%283 = OpCompositeConstruct  %176  %18 %18
+%282 = OpIMul  %176  %281 %283
+%284 = OpCompositeConstruct  %34  %24 %24
+%286 = OpCompositeConstruct  %34  %25 %25
+%285 = OpIMul  %34  %284 %286
+%287 = OpCompositeConstruct  %34  %25 %25
 %289 = OpCompositeConstruct  %34  %24 %24
-%290 = OpCompositeConstruct  %34  %25 %25
-%291 = OpUDiv  %34  %289 %290
-%292 = OpCompositeConstruct  %34  %25 %25
-%293 = OpCompositeConstruct  %34  %24 %24
-%294 = OpUDiv  %34  %293 %292
-%295 = OpCompositeConstruct  %31  %14 %14
-%296 = OpCompositeConstruct  %31  %3 %3
-%297 = OpFDiv  %31  %295 %296
-%298 = OpCompositeConstruct  %31  %3 %3
-%299 = OpCompositeConstruct  %31  %14 %14
-%300 = OpFDiv  %31  %299 %298
-%301 = OpCompositeConstruct  %165  %18 %18
-%302 = OpCompositeConstruct  %165  %7 %7
-%303 = OpSRem  %165  %301 %302
-%304 = OpCompositeConstruct  %165  %7 %7
-%305 = OpCompositeConstruct  %165  %18 %18
-%306 = OpSRem  %165  %305 %304
-%307 = OpCompositeConstruct  %34  %24 %24
-%308 = OpCompositeConstruct  %34  %25 %25
-%309 = OpUMod  %34  %307 %308
-%310 = OpCompositeConstruct  %34  %25 %25
-%311 = OpCompositeConstruct  %34  %24 %24
-%312 = OpUMod  %34  %311 %310
-%313 = OpCompositeConstruct  %31  %14 %14
-%314 = OpCompositeConstruct  %31  %3 %3
-%315 = OpFRem  %31  %313 %314
-%316 = OpCompositeConstruct  %31  %3 %3
-%317 = OpCompositeConstruct  %31  %14 %14
-%318 = OpFRem  %31  %317 %316
-%320 = OpCompositeExtract  %29  %54 0
-%321 = OpCompositeExtract  %29  %54 0
-%322 = OpFAdd  %29  %320 %321
-%323 = OpCompositeExtract  %29  %54 1
-%324 = OpCompositeExtract  %29  %54 1
-%325 = OpFAdd  %29  %323 %324
-%326 = OpCompositeExtract  %29  %54 2
-%327 = OpCompositeExtract  %29  %54 2
-%328 = OpFAdd  %29  %326 %327
-%319 = OpCompositeConstruct  %38  %322 %325 %328
-%330 = OpCompositeExtract  %29  %54 0
+%288 = OpIMul  %34  %287 %289
+%290 = OpCompositeConstruct  %31  %14 %14
+%291 = OpVectorTimesScalar  %31  %290 %3
+%292 = OpCompositeConstruct  %31  %3 %3
+%293 = OpVectorTimesScalar  %31  %292 %14
+%294 = OpCompositeConstruct  %176  %18 %18
+%295 = OpCompositeConstruct  %176  %7 %7
+%296 = OpSDiv  %176  %294 %295
+%297 = OpCompositeConstruct  %176  %7 %7
+%298 = OpCompositeConstruct  %176  %18 %18
+%299 = OpSDiv  %176  %298 %297
+%300 = OpCompositeConstruct  %34  %24 %24
+%301 = OpCompositeConstruct  %34  %25 %25
+%302 = OpUDiv  %34  %300 %301
+%303 = OpCompositeConstruct  %34  %25 %25
+%304 = OpCompositeConstruct  %34  %24 %24
+%305 = OpUDiv  %34  %304 %303
+%306 = OpCompositeConstruct  %31  %14 %14
+%307 = OpCompositeConstruct  %31  %3 %3
+%308 = OpFDiv  %31  %306 %307
+%309 = OpCompositeConstruct  %31  %3 %3
+%310 = OpCompositeConstruct  %31  %14 %14
+%311 = OpFDiv  %31  %310 %309
+%312 = OpCompositeConstruct  %176  %18 %18
+%313 = OpCompositeConstruct  %176  %7 %7
+%314 = OpSRem  %176  %312 %313
+%315 = OpCompositeConstruct  %176  %7 %7
+%316 = OpCompositeConstruct  %176  %18 %18
+%317 = OpSRem  %176  %316 %315
+%318 = OpCompositeConstruct  %34  %24 %24
+%319 = OpCompositeConstruct  %34  %25 %25
+%320 = OpUMod  %34  %318 %319
+%321 = OpCompositeConstruct  %34  %25 %25
+%322 = OpCompositeConstruct  %34  %24 %24
+%323 = OpUMod  %34  %322 %321
+%324 = OpCompositeConstruct  %31  %14 %14
+%325 = OpCompositeConstruct  %31  %3 %3
+%326 = OpFRem  %31  %324 %325
+%327 = OpCompositeConstruct  %31  %3 %3
+%328 = OpCompositeConstruct  %31  %14 %14
+%329 = OpFRem  %31  %328 %327
 %331 = OpCompositeExtract  %29  %54 0
-%332 = OpFSub  %29  %330 %331
-%333 = OpCompositeExtract  %29  %54 1
+%332 = OpCompositeExtract  %29  %54 0
+%333 = OpFAdd  %29  %331 %332
 %334 = OpCompositeExtract  %29  %54 1
-%335 = OpFSub  %29  %333 %334
-%336 = OpCompositeExtract  %29  %54 2
+%335 = OpCompositeExtract  %29  %54 1
+%336 = OpFAdd  %29  %334 %335
 %337 = OpCompositeExtract  %29  %54 2
-%338 = OpFSub  %29  %336 %337
-%329 = OpCompositeConstruct  %38  %332 %335 %338
-%339 = OpMatrixTimesScalar  %38  %54 %3
-%340 = OpMatrixTimesScalar  %38  %54 %14
-%341 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%342 = OpMatrixTimesVector  %29  %55 %341
-%343 = OpCompositeConstruct  %29  %14 %14 %14
-%344 = OpVectorTimesMatrix  %26  %343 %55
-%345 = OpMatrixTimesMatrix  %38  %55 %56
+%338 = OpCompositeExtract  %29  %54 2
+%339 = OpFAdd  %29  %337 %338
+%330 = OpCompositeConstruct  %38  %333 %336 %339
+%341 = OpCompositeExtract  %29  %54 0
+%342 = OpCompositeExtract  %29  %54 0
+%343 = OpFSub  %29  %341 %342
+%344 = OpCompositeExtract  %29  %54 1
+%345 = OpCompositeExtract  %29  %54 1
+%346 = OpFSub  %29  %344 %345
+%347 = OpCompositeExtract  %29  %54 2
+%348 = OpCompositeExtract  %29  %54 2
+%349 = OpFSub  %29  %347 %348
+%340 = OpCompositeConstruct  %38  %343 %346 %349
+%350 = OpMatrixTimesScalar  %38  %54 %3
+%351 = OpMatrixTimesScalar  %38  %54 %14
+%352 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%353 = OpMatrixTimesVector  %29  %55 %352
+%354 = OpCompositeConstruct  %29  %14 %14 %14
+%355 = OpVectorTimesMatrix  %26  %354 %55
+%356 = OpMatrixTimesMatrix  %38  %55 %56
 OpReturn
 OpFunctionEnd
-%347 = OpFunction  %2  None %146
-%346 = OpLabel
-OpBranch %348
-%348 = OpLabel
-%349 = OpNot  %8  %7
-%350 = OpNot  %20  %25
-%351 = OpCompositeConstruct  %165  %7 %7
-%352 = OpNot  %165  %351
-%353 = OpCompositeConstruct  %176  %25 %25 %25
-%354 = OpNot  %176  %353
-%355 = OpBitwiseOr  %8  %18 %7
-%356 = OpBitwiseOr  %20  %24 %25
-%357 = OpCompositeConstruct  %165  %18 %18
-%358 = OpCompositeConstruct  %165  %7 %7
-%359 = OpBitwiseOr  %165  %357 %358
-%360 = OpCompositeConstruct  %176  %24 %24 %24
-%361 = OpCompositeConstruct  %176  %25 %25 %25
-%362 = OpBitwiseOr  %176  %360 %361
-%363 = OpBitwiseAnd  %8  %18 %7
-%364 = OpBitwiseAnd  %20  %24 %25
-%365 = OpCompositeConstruct  %165  %18 %18
-%366 = OpCompositeConstruct  %165  %7 %7
-%367 = OpBitwiseAnd  %165  %365 %366
-%368 = OpCompositeConstruct  %176  %24 %24 %24
-%369 = OpCompositeConstruct  %176  %25 %25 %25
-%370 = OpBitwiseAnd  %176  %368 %369
-%371 = OpBitwiseXor  %8  %18 %7
-%372 = OpBitwiseXor  %20  %24 %25
-%373 = OpCompositeConstruct  %165  %18 %18
-%374 = OpCompositeConstruct  %165  %7 %7
-%375 = OpBitwiseXor  %165  %373 %374
-%376 = OpCompositeConstruct  %176  %24 %24 %24
-%377 = OpCompositeConstruct  %176  %25 %25 %25
-%378 = OpBitwiseXor  %176  %376 %377
-%379 = OpShiftLeftLogical  %8  %18 %25
-%380 = OpShiftLeftLogical  %20  %24 %25
-%381 = OpCompositeConstruct  %165  %18 %18
-%382 = OpCompositeConstruct  %34  %25 %25
-%383 = OpShiftLeftLogical  %165  %381 %382
-%384 = OpCompositeConstruct  %176  %24 %24 %24
-%385 = OpCompositeConstruct  %176  %25 %25 %25
-%386 = OpShiftLeftLogical  %176  %384 %385
-%387 = OpShiftRightArithmetic  %8  %18 %25
-%388 = OpShiftRightLogical  %20  %24 %25
-%389 = OpCompositeConstruct  %165  %18 %18
-%390 = OpCompositeConstruct  %34  %25 %25
-%391 = OpShiftRightArithmetic  %165  %389 %390
-%392 = OpCompositeConstruct  %176  %24 %24 %24
-%393 = OpCompositeConstruct  %176  %25 %25 %25
-%394 = OpShiftRightLogical  %176  %392 %393
+%358 = OpFunction  %2  None %151
+%357 = OpLabel
+OpBranch %359
+%359 = OpLabel
+%360 = OpNot  %8  %7
+%361 = OpNot  %20  %25
+%362 = OpCompositeConstruct  %176  %7 %7
+%363 = OpNot  %176  %362
+%364 = OpCompositeConstruct  %187  %25 %25 %25
+%365 = OpNot  %187  %364
+%366 = OpBitwiseOr  %8  %18 %7
+%367 = OpBitwiseOr  %20  %24 %25
+%368 = OpCompositeConstruct  %176  %18 %18
+%369 = OpCompositeConstruct  %176  %7 %7
+%370 = OpBitwiseOr  %176  %368 %369
+%371 = OpCompositeConstruct  %187  %24 %24 %24
+%372 = OpCompositeConstruct  %187  %25 %25 %25
+%373 = OpBitwiseOr  %187  %371 %372
+%374 = OpBitwiseAnd  %8  %18 %7
+%375 = OpBitwiseAnd  %20  %24 %25
+%376 = OpCompositeConstruct  %176  %18 %18
+%377 = OpCompositeConstruct  %176  %7 %7
+%378 = OpBitwiseAnd  %176  %376 %377
+%379 = OpCompositeConstruct  %187  %24 %24 %24
+%380 = OpCompositeConstruct  %187  %25 %25 %25
+%381 = OpBitwiseAnd  %187  %379 %380
+%382 = OpBitwiseXor  %8  %18 %7
+%383 = OpBitwiseXor  %20  %24 %25
+%384 = OpCompositeConstruct  %176  %18 %18
+%385 = OpCompositeConstruct  %176  %7 %7
+%386 = OpBitwiseXor  %176  %384 %385
+%387 = OpCompositeConstruct  %187  %24 %24 %24
+%388 = OpCompositeConstruct  %187  %25 %25 %25
+%389 = OpBitwiseXor  %187  %387 %388
+%390 = OpShiftLeftLogical  %8  %18 %25
+%391 = OpShiftLeftLogical  %20  %24 %25
+%392 = OpCompositeConstruct  %176  %18 %18
+%393 = OpCompositeConstruct  %34  %25 %25
+%394 = OpShiftLeftLogical  %176  %392 %393
+%395 = OpCompositeConstruct  %187  %24 %24 %24
+%396 = OpCompositeConstruct  %187  %25 %25 %25
+%397 = OpShiftLeftLogical  %187  %395 %396
+%398 = OpShiftRightArithmetic  %8  %18 %25
+%399 = OpShiftRightLogical  %20  %24 %25
+%400 = OpCompositeConstruct  %176  %18 %18
+%401 = OpCompositeConstruct  %34  %25 %25
+%402 = OpShiftRightArithmetic  %176  %400 %401
+%403 = OpCompositeConstruct  %187  %24 %24 %24
+%404 = OpCompositeConstruct  %187  %25 %25 %25
+%405 = OpShiftRightLogical  %187  %403 %404
 OpReturn
 OpFunctionEnd
-%396 = OpFunction  %2  None %146
-%395 = OpLabel
-OpBranch %397
-%397 = OpLabel
-%398 = OpIEqual  %10  %18 %7
-%399 = OpIEqual  %10  %24 %25
-%400 = OpFOrdEqual  %10  %14 %3
-%401 = OpCompositeConstruct  %165  %18 %18
-%402 = OpCompositeConstruct  %165  %7 %7
-%403 = OpIEqual  %149  %401 %402
-%404 = OpCompositeConstruct  %176  %24 %24 %24
-%405 = OpCompositeConstruct  %176  %25 %25 %25
-%406 = OpIEqual  %104  %404 %405
-%407 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%408 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%409 = OpFOrdEqual  %28  %407 %408
-%410 = OpINotEqual  %10  %18 %7
-%411 = OpINotEqual  %10  %24 %25
-%412 = OpFOrdNotEqual  %10  %14 %3
-%413 = OpCompositeConstruct  %165  %18 %18
-%414 = OpCompositeConstruct  %165  %7 %7
-%415 = OpINotEqual  %149  %413 %414
-%416 = OpCompositeConstruct  %176  %24 %24 %24
-%417 = OpCompositeConstruct  %176  %25 %25 %25
-%418 = OpINotEqual  %104  %416 %417
-%419 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%420 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%421 = OpFOrdNotEqual  %28  %419 %420
-%422 = OpSLessThan  %10  %18 %7
-%423 = OpULessThan  %10  %24 %25
-%424 = OpFOrdLessThan  %10  %14 %3
-%425 = OpCompositeConstruct  %165  %18 %18
-%426 = OpCompositeConstruct  %165  %7 %7
-%427 = OpSLessThan  %149  %425 %426
-%428 = OpCompositeConstruct  %176  %24 %24 %24
-%429 = OpCompositeConstruct  %176  %25 %25 %25
-%430 = OpULessThan  %104  %428 %429
-%431 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%432 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%433 = OpFOrdLessThan  %28  %431 %432
-%434 = OpSLessThanEqual  %10  %18 %7
-%435 = OpULessThanEqual  %10  %24 %25
-%436 = OpFOrdLessThanEqual  %10  %14 %3
-%437 = OpCompositeConstruct  %165  %18 %18
-%438 = OpCompositeConstruct  %165  %7 %7
-%439 = OpSLessThanEqual  %149  %437 %438
-%440 = OpCompositeConstruct  %176  %24 %24 %24
-%441 = OpCompositeConstruct  %176  %25 %25 %25
-%442 = OpULessThanEqual  %104  %440 %441
-%443 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%444 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%445 = OpFOrdLessThanEqual  %28  %443 %444
-%446 = OpSGreaterThan  %10  %18 %7
-%447 = OpUGreaterThan  %10  %24 %25
-%448 = OpFOrdGreaterThan  %10  %14 %3
-%449 = OpCompositeConstruct  %165  %18 %18
-%450 = OpCompositeConstruct  %165  %7 %7
-%451 = OpSGreaterThan  %149  %449 %450
-%452 = OpCompositeConstruct  %176  %24 %24 %24
-%453 = OpCompositeConstruct  %176  %25 %25 %25
-%454 = OpUGreaterThan  %104  %452 %453
-%455 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%456 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%457 = OpFOrdGreaterThan  %28  %455 %456
-%458 = OpSGreaterThanEqual  %10  %18 %7
-%459 = OpUGreaterThanEqual  %10  %24 %25
-%460 = OpFOrdGreaterThanEqual  %10  %14 %3
-%461 = OpCompositeConstruct  %165  %18 %18
-%462 = OpCompositeConstruct  %165  %7 %7
-%463 = OpSGreaterThanEqual  %149  %461 %462
-%464 = OpCompositeConstruct  %176  %24 %24 %24
-%465 = OpCompositeConstruct  %176  %25 %25 %25
-%466 = OpUGreaterThanEqual  %104  %464 %465
-%467 = OpCompositeConstruct  %26  %14 %14 %14 %14
-%468 = OpCompositeConstruct  %26  %3 %3 %3 %3
-%469 = OpFOrdGreaterThanEqual  %28  %467 %468
+%407 = OpFunction  %2  None %151
+%406 = OpLabel
+OpBranch %408
+%408 = OpLabel
+%409 = OpIEqual  %10  %18 %7
+%410 = OpIEqual  %10  %24 %25
+%411 = OpFOrdEqual  %10  %14 %3
+%412 = OpCompositeConstruct  %176  %18 %18
+%413 = OpCompositeConstruct  %176  %7 %7
+%414 = OpIEqual  %154  %412 %413
+%415 = OpCompositeConstruct  %187  %24 %24 %24
+%416 = OpCompositeConstruct  %187  %25 %25 %25
+%417 = OpIEqual  %104  %415 %416
+%418 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%419 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%420 = OpFOrdEqual  %28  %418 %419
+%421 = OpINotEqual  %10  %18 %7
+%422 = OpINotEqual  %10  %24 %25
+%423 = OpFOrdNotEqual  %10  %14 %3
+%424 = OpCompositeConstruct  %176  %18 %18
+%425 = OpCompositeConstruct  %176  %7 %7
+%426 = OpINotEqual  %154  %424 %425
+%427 = OpCompositeConstruct  %187  %24 %24 %24
+%428 = OpCompositeConstruct  %187  %25 %25 %25
+%429 = OpINotEqual  %104  %427 %428
+%430 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%431 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%432 = OpFOrdNotEqual  %28  %430 %431
+%433 = OpSLessThan  %10  %18 %7
+%434 = OpULessThan  %10  %24 %25
+%435 = OpFOrdLessThan  %10  %14 %3
+%436 = OpCompositeConstruct  %176  %18 %18
+%437 = OpCompositeConstruct  %176  %7 %7
+%438 = OpSLessThan  %154  %436 %437
+%439 = OpCompositeConstruct  %187  %24 %24 %24
+%440 = OpCompositeConstruct  %187  %25 %25 %25
+%441 = OpULessThan  %104  %439 %440
+%442 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%443 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%444 = OpFOrdLessThan  %28  %442 %443
+%445 = OpSLessThanEqual  %10  %18 %7
+%446 = OpULessThanEqual  %10  %24 %25
+%447 = OpFOrdLessThanEqual  %10  %14 %3
+%448 = OpCompositeConstruct  %176  %18 %18
+%449 = OpCompositeConstruct  %176  %7 %7
+%450 = OpSLessThanEqual  %154  %448 %449
+%451 = OpCompositeConstruct  %187  %24 %24 %24
+%452 = OpCompositeConstruct  %187  %25 %25 %25
+%453 = OpULessThanEqual  %104  %451 %452
+%454 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%455 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%456 = OpFOrdLessThanEqual  %28  %454 %455
+%457 = OpSGreaterThan  %10  %18 %7
+%458 = OpUGreaterThan  %10  %24 %25
+%459 = OpFOrdGreaterThan  %10  %14 %3
+%460 = OpCompositeConstruct  %176  %18 %18
+%461 = OpCompositeConstruct  %176  %7 %7
+%462 = OpSGreaterThan  %154  %460 %461
+%463 = OpCompositeConstruct  %187  %24 %24 %24
+%464 = OpCompositeConstruct  %187  %25 %25 %25
+%465 = OpUGreaterThan  %104  %463 %464
+%466 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%467 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%468 = OpFOrdGreaterThan  %28  %466 %467
+%469 = OpSGreaterThanEqual  %10  %18 %7
+%470 = OpUGreaterThanEqual  %10  %24 %25
+%471 = OpFOrdGreaterThanEqual  %10  %14 %3
+%472 = OpCompositeConstruct  %176  %18 %18
+%473 = OpCompositeConstruct  %176  %7 %7
+%474 = OpSGreaterThanEqual  %154  %472 %473
+%475 = OpCompositeConstruct  %187  %24 %24 %24
+%476 = OpCompositeConstruct  %187  %25 %25 %25
+%477 = OpUGreaterThanEqual  %104  %475 %476
+%478 = OpCompositeConstruct  %26  %14 %14 %14 %14
+%479 = OpCompositeConstruct  %26  %3 %3 %3 %3
+%480 = OpFOrdGreaterThanEqual  %28  %478 %479
 OpReturn
 OpFunctionEnd
-%475 = OpFunction  %2  None %146
-%474 = OpLabel
-%470 = OpVariable  %471  Function %7
-%472 = OpVariable  %473  Function %57
-OpBranch %476
-%476 = OpLabel
-%477 = OpLoad  %8  %470
-%478 = OpIAdd  %8  %477 %7
-OpStore %470 %478
-%479 = OpLoad  %8  %470
-%480 = OpISub  %8  %479 %7
-OpStore %470 %480
-%481 = OpLoad  %8  %470
-%482 = OpLoad  %8  %470
-%483 = OpIMul  %8  %481 %482
-OpStore %470 %483
-%484 = OpLoad  %8  %470
-%485 = OpLoad  %8  %470
-%486 = OpSDiv  %8  %484 %485
-OpStore %470 %486
-%487 = OpLoad  %8  %470
-%488 = OpSRem  %8  %487 %7
-OpStore %470 %488
-%489 = OpLoad  %8  %470
-%490 = OpBitwiseAnd  %8  %489 %11
-OpStore %470 %490
-%491 = OpLoad  %8  %470
-%492 = OpBitwiseOr  %8  %491 %11
-OpStore %470 %492
-%493 = OpLoad  %8  %470
-%494 = OpBitwiseXor  %8  %493 %11
-OpStore %470 %494
-%495 = OpLoad  %8  %470
-%496 = OpShiftLeftLogical  %8  %495 %24
-OpStore %470 %496
-%497 = OpLoad  %8  %470
-%498 = OpShiftRightArithmetic  %8  %497 %25
-OpStore %470 %498
-%499 = OpLoad  %8  %470
-%500 = OpIAdd  %8  %499 %7
-OpStore %470 %500
-%501 = OpLoad  %8  %470
-%502 = OpISub  %8  %501 %7
-OpStore %470 %502
-%504 = OpAccessChain  %503  %472 %25
-%505 = OpLoad  %8  %504
-%506 = OpIAdd  %8  %505 %7
-%507 = OpAccessChain  %503  %472 %25
-OpStore %507 %506
-%508 = OpAccessChain  %503  %472 %25
-%509 = OpLoad  %8  %508
-%510 = OpISub  %8  %509 %7
-%511 = OpAccessChain  %503  %472 %25
-OpStore %511 %510
+%486 = OpFunction  %2  None %151
+%485 = OpLabel
+%481 = OpVariable  %482  Function %7
+%483 = OpVariable  %484  Function %57
+OpBranch %487
+%487 = OpLabel
+%488 = OpLoad  %8  %481
+%489 = OpIAdd  %8  %488 %7
+OpStore %481 %489
+%490 = OpLoad  %8  %481
+%491 = OpISub  %8  %490 %7
+OpStore %481 %491
+%492 = OpLoad  %8  %481
+%493 = OpLoad  %8  %481
+%494 = OpIMul  %8  %492 %493
+OpStore %481 %494
+%495 = OpLoad  %8  %481
+%496 = OpLoad  %8  %481
+%497 = OpSDiv  %8  %495 %496
+OpStore %481 %497
+%498 = OpLoad  %8  %481
+%499 = OpSRem  %8  %498 %7
+OpStore %481 %499
+%500 = OpLoad  %8  %481
+%501 = OpBitwiseAnd  %8  %500 %11
+OpStore %481 %501
+%502 = OpLoad  %8  %481
+%503 = OpBitwiseOr  %8  %502 %11
+OpStore %481 %503
+%504 = OpLoad  %8  %481
+%505 = OpBitwiseXor  %8  %504 %11
+OpStore %481 %505
+%506 = OpLoad  %8  %481
+%507 = OpShiftLeftLogical  %8  %506 %24
+OpStore %481 %507
+%508 = OpLoad  %8  %481
+%509 = OpShiftRightArithmetic  %8  %508 %25
+OpStore %481 %509
+%510 = OpLoad  %8  %481
+%511 = OpIAdd  %8  %510 %7
+OpStore %481 %511
+%512 = OpLoad  %8  %481
+%513 = OpISub  %8  %512 %7
+OpStore %481 %513
+%515 = OpAccessChain  %514  %483 %25
+%516 = OpLoad  %8  %515
+%517 = OpIAdd  %8  %516 %7
+%518 = OpAccessChain  %514  %483 %25
+OpStore %518 %517
+%519 = OpAccessChain  %514  %483 %25
+%520 = OpLoad  %8  %519
+%521 = OpISub  %8  %520 %7
+%522 = OpAccessChain  %514  %483 %25
+OpStore %522 %521
 OpReturn
 OpFunctionEnd
-%513 = OpFunction  %2  None %146
-%512 = OpLabel
-OpBranch %514
-%514 = OpLabel
-%515 = OpFunctionCall  %26  %59
-%516 = OpFunctionCall  %26  %84
-%517 = OpVectorShuffle  %29  %42 %42 0 1 2
-%518 = OpFunctionCall  %29  %101 %517
-%519 = OpFunctionCall  %4  %114
-%520 = OpFunctionCall  %2  %145
-%521 = OpFunctionCall  %2  %163
-%522 = OpFunctionCall  %2  %347
-%523 = OpFunctionCall  %2  %396
-%524 = OpFunctionCall  %2  %475
+%524 = OpFunction  %2  None %151
+%523 = OpLabel
+OpBranch %525
+%525 = OpLabel
+%526 = OpFunctionCall  %26  %59
+%527 = OpFunctionCall  %26  %84
+%528 = OpVectorShuffle  %29  %42 %42 0 1 2
+%529 = OpFunctionCall  %29  %101 %528
+%530 = OpFunctionCall  %4  %114
+%531 = OpFunctionCall  %2  %150
+%532 = OpFunctionCall  %2  %174
+%533 = OpFunctionCall  %2  %358
+%534 = OpFunctionCall  %2  %407
+%535 = OpFunctionCall  %2  %486
 OpReturn
 OpFunctionEnd
\ No newline at end of file
diff --git a/tests/out/spv/short_circuit.spvasm b/tests/out/spv/short_circuit.spvasm
new file mode 100644
index 0000000000..2e631fe19c
--- /dev/null
+++ b/tests/out/spv/short_circuit.spvasm
@@ -0,0 +1,140 @@
+; SPIR-V
+; Version: 1.1
+; Generator: rspirv
+; Bound: 76
+OpCapability Shader
+%1 = OpExtInstImport "GLSL.std.450"
+OpMemoryModel Logical GLSL450
+OpEntryPoint GLCompute %35 "main"
+OpExecutionMode %35 LocalSize 1 1 1
+%2 = OpTypeVoid
+%4 = OpTypeBool
+%3 = OpConstantTrue  %4
+%5 = OpConstantFalse  %4
+%8 = OpTypeFunction %4
+%20 = OpTypePointer Function %4
+%21 = OpConstantNull  %4
+%23 = OpConstantNull  %4
+%25 = OpConstantNull  %4
+%27 = OpConstantNull  %4
+%29 = OpConstantNull  %4
+%31 = OpConstantNull  %4
+%33 = OpConstantNull  %4
+%36 = OpTypeFunction %2
+%7 = OpFunction  %4  None %8
+%6 = OpLabel
+OpBranch %9
+%9 = OpLabel
+OpReturnValue %3
+OpFunctionEnd
+%11 = OpFunction  %4  None %8
+%10 = OpLabel
+OpBranch %12
+%12 = OpLabel
+OpReturnValue %3
+OpFunctionEnd
+%14 = OpFunction  %4  None %8
+%13 = OpLabel
+OpBranch %15
+%15 = OpLabel
+OpReturnValue %3
+OpFunctionEnd
+%17 = OpFunction  %4  None %8
+%16 = OpLabel
+OpBranch %18
+%18 = OpLabel
+OpReturnValue %3
+OpFunctionEnd
+%35 = OpFunction  %2  None %36
+%34 = OpLabel
+%28 = OpVariable  %20  Function %29
+%22 = OpVariable  %20  Function %23
+%32 = OpVariable  %20  Function %33
+%26 = OpVariable  %20  Function %27
+%19 = OpVariable  %20  Function %21
+%30 = OpVariable  %20  Function %31
+%24 = OpVariable  %20  Function %25
+OpBranch %37
+%37 = OpLabel
+%38 = OpFunctionCall  %4  %7
+OpSelectionMerge %39 None
+OpBranchConditional %38 %40 %41
+%40 = OpLabel
+OpStore %19 %3
+OpBranch %39
+%41 = OpLabel
+%42 = OpFunctionCall  %4  %11
+OpStore %19 %42
+OpBranch %39
+%39 = OpLabel
+%43 = OpLoad  %4  %19
+OpSelectionMerge %44 None
+OpBranchConditional %43 %45 %46
+%45 = OpLabel
+OpStore %22 %3
+OpBranch %44
+%46 = OpLabel
+%47 = OpFunctionCall  %4  %14
+OpStore %22 %47
+OpBranch %44
+%44 = OpLabel
+%48 = OpLoad  %4  %22
+%49 = OpFunctionCall  %4  %7
+OpSelectionMerge %50 None
+OpBranchConditional %49 %51 %52
+%51 = OpLabel
+%53 = OpFunctionCall  %4  %11
+OpStore %24 %53
+OpBranch %50
+%52 = OpLabel
+OpStore %24 %5
+OpBranch %50
+%50 = OpLabel
+%54 = OpLoad  %4  %24
+OpSelectionMerge %55 None
+OpBranchConditional %54 %56 %57
+%56 = OpLabel
+%58 = OpFunctionCall  %4  %14
+OpStore %26 %58
+OpBranch %55
+%57 = OpLabel
+OpStore %26 %5
+OpBranch %55
+%55 = OpLabel
+%59 = OpLoad  %4  %26
+%60 = OpFunctionCall  %4  %7
+OpSelectionMerge %61 None
+OpBranchConditional %60 %62 %63
+%62 = OpLabel
+OpStore %28 %3
+OpBranch %61
+%63 = OpLabel
+%64 = OpFunctionCall  %4  %11
+OpStore %28 %64
+OpBranch %61
+%61 = OpLabel
+%65 = OpLoad  %4  %28
+OpSelectionMerge %66 None
+OpBranchConditional %65 %67 %68
+%67 = OpLabel
+%69 = OpFunctionCall  %4  %14
+OpSelectionMerge %70 None
+OpBranchConditional %69 %71 %72
+%71 = OpLabel
+OpStore %30 %3
+OpBranch %70
+%72 = OpLabel
+%73 = OpFunctionCall  %4  %17
+OpStore %30 %73
+OpBranch %70
+%70 = OpLabel
+%74 = OpLoad  %4  %30
+OpStore %32 %74
+OpBranch %66
+%68 = OpLabel
+OpStore %32 %5
+OpBranch %66
+%66 = OpLabel
+%75 = OpLoad  %4  %32
+OpReturn
+OpFunctionEnd
\ No newline at end of file
diff --git a/tests/out/wgsl/bevy-pbr-frag.wgsl b/tests/out/wgsl/bevy-pbr-frag.wgsl
index 339012853b..12df9c56ea 100644
--- a/tests/out/wgsl/bevy-pbr-frag.wgsl
+++ b/tests/out/wgsl/bevy-pbr-frag.wgsl
@@ -1057,7 +1057,9 @@ fn main_1() {
     var R_4: vec3<f32>;
     var light_accum: vec3<f32> = vec3<f32>(0.0, 0.0, 0.0);
     var i: i32 = 0;
+    var local_3: bool;
     var i_1: i32 = 0;
+    var local_4: bool;
     var diffuse_ambient: vec3<f32>;
     var specular_ambient: vec3<f32>;
 
@@ -1190,14 +1192,20 @@ fn main_1() {
     loop {
         let _e227 = i;
         let _e228 = global_2.NumLights;
-        let _e232 = i;
-        if !(((_e227 < i32(_e228.x)) && (_e232 < 10))) {
+        if (_e227 < i32(_e228.x)) {
+            let _e232 = i;
+            local_3 = (_e232 < 10);
+        } else {
+            local_3 = false;
+        }
+        let _e236 = local_3;
+        if !(_e236) {
             break;
         }
         {
-            let _e239 = light_accum;
-            let _e240 = i;
-            _ = global_2.PointLights[_e240];
+            let _e241 = light_accum;
+            let _e242 = i;
+            _ = global_2.PointLights[_e242];
             _ = roughness_12;
             _ = NdotV_4;
             _ = N_2;
@@ -1205,34 +1213,40 @@ fn main_1() {
             _ = R_4;
             _ = F0_4;
             _ = diffuseColor_4;
-            let _e250 = i;
-            let _e252 = global_2.PointLights[_e250];
-            let _e253 = roughness_12;
-            let _e254 = NdotV_4;
-            let _e255 = N_2;
-            let _e256 = V_3;
-            let _e257 = R_4;
-            let _e258 = F0_4;
-            let _e259 = diffuseColor_4;
-            let _e260 = point_light(_e252, _e253, _e254, _e255, _e256, _e257, _e258, _e259);
-            light_accum = (_e239 + _e260);
+            let _e252 = i;
+            let _e254 = global_2.PointLights[_e252];
+            let _e255 = roughness_12;
+            let _e256 = NdotV_4;
+            let _e257 = N_2;
+            let _e258 = V_3;
+            let _e259 = R_4;
+            let _e260 = F0_4;
+            let _e261 = diffuseColor_4;
+            let _e262 = point_light(_e254, _e255, _e256, _e257, _e258, _e259, _e260, _e261);
+            light_accum = (_e241 + _e262);
         }
         continuing {
-            let _e236 = i;
-            i = (_e236 + 1);
+            let _e238 = i;
+            i = (_e238 + 1);
         }
     }
     loop {
-        let _e264 = i_1;
-        let _e265 = global_2.NumLights;
-        let _e269 = i_1;
-        if !(((_e264 < i32(_e265.y)) && (_e269 < 1))) {
+        let _e266 = i_1;
+        let _e267 = global_2.NumLights;
+        if (_e266 < i32(_e267.y)) {
+            let _e271 = i_1;
+            local_4 = (_e271 < 1);
+        } else {
+            local_4 = false;
+        }
+        let _e275 = local_4;
+        if !(_e275) {
             break;
         }
         {
-            let _e276 = light_accum;
-            let _e277 = i_1;
-            _ = global_2.DirectionalLights[_e277];
+            let _e280 = light_accum;
+            let _e281 = i_1;
+            _ = global_2.DirectionalLights[_e281];
             _ = roughness_12;
             _ = NdotV_4;
             _ = N_2;
@@ -1240,74 +1254,74 @@ fn main_1() {
             _ = R_4;
             _ = F0_4;
             _ = diffuseColor_4;
-            let _e287 = i_1;
-            let _e289 = global_2.DirectionalLights[_e287];
-            let _e290 = roughness_12;
-            let _e291 = NdotV_4;
-            let _e292 = N_2;
-            let _e293 = V_3;
-            let _e294 = R_4;
-            let _e295 = F0_4;
-            let _e296 = diffuseColor_4;
-            let _e297 = dir_light(_e289, _e290, _e291, _e292, _e293, _e294, _e295, _e296);
-            light_accum = (_e276 + _e297);
+            let _e291 = i_1;
+            let _e293 = global_2.DirectionalLights[_e291];
+            let _e294 = roughness_12;
+            let _e295 = NdotV_4;
+            let _e296 = N_2;
+            let _e297 = V_3;
+            let _e298 = R_4;
+            let _e299 = F0_4;
+            let _e300 = diffuseColor_4;
+            let _e301 = dir_light(_e293, _e294, _e295, _e296, _e297, _e298, _e299, _e300);
+            light_accum = (_e280 + _e301);
         }
         continuing {
-            let _e273 = i_1;
-            i_1 = (_e273 + 1);
+            let _e277 = i_1;
+            i_1 = (_e277 + 1);
         }
     }
     _ = diffuseColor_4;
     _ = NdotV_4;
-    let _e302 = diffuseColor_4;
-    let _e304 = NdotV_4;
-    let _e305 = EnvBRDFApprox(_e302, 1.0, _e304);
-    diffuse_ambient = _e305;
+    let _e306 = diffuseColor_4;
+    let _e308 = NdotV_4;
+    let _e309 = EnvBRDFApprox(_e306, 1.0, _e308);
+    diffuse_ambient = _e309;
     _ = F0_4;
     _ = perceptual_roughness_2;
     _ = NdotV_4;
-    let _e310 = F0_4;
-    let _e311 = perceptual_roughness_2;
-    let _e312 = NdotV_4;
-    let _e313 = EnvBRDFApprox(_e310, _e311, _e312);
-    specular_ambient = _e313;
-    let _e315 = output_color;
-    _ = _e315.xyz;
-    let _e317 = light_accum;
-    output_color.x = _e317.x;
-    output_color.y = _e317.y;
-    output_color.z = _e317.z;
-    let _e324 = output_color;
-    _ = _e324.xyz;
-    let _e326 = output_color;
-    let _e328 = diffuse_ambient;
-    let _e329 = specular_ambient;
-    let _e331 = global_2.AmbientColor;
-    let _e334 = occlusion;
-    let _e336 = (_e326.xyz + (((_e328 + _e329) * _e331.xyz) * _e334));
-    output_color.x = _e336.x;
-    output_color.y = _e336.y;
-    output_color.z = _e336.z;
-    let _e343 = output_color;
-    _ = _e343.xyz;
-    let _e345 = output_color;
-    let _e347 = emissive;
+    let _e314 = F0_4;
+    let _e315 = perceptual_roughness_2;
+    let _e316 = NdotV_4;
+    let _e317 = EnvBRDFApprox(_e314, _e315, _e316);
+    specular_ambient = _e317;
+    let _e319 = output_color;
+    _ = _e319.xyz;
+    let _e321 = light_accum;
+    output_color.x = _e321.x;
+    output_color.y = _e321.y;
+    output_color.z = _e321.z;
+    let _e328 = output_color;
+    _ = _e328.xyz;
+    let _e330 = output_color;
+    let _e332 = diffuse_ambient;
+    let _e333 = specular_ambient;
+    let _e335 = global_2.AmbientColor;
+    let _e338 = occlusion;
+    let _e340 = (_e330.xyz + (((_e332 + _e333) * _e335.xyz) * _e338));
+    output_color.x = _e340.x;
+    output_color.y = _e340.y;
+    output_color.z = _e340.z;
+    let _e347 = output_color;
+    _ = _e347.xyz;
     let _e349 = output_color;
-    let _e352 = (_e345.xyz + (_e347.xyz * _e349.w));
-    output_color.x = _e352.x;
-    output_color.y = _e352.y;
-    output_color.z = _e352.z;
-    let _e359 = output_color;
-    _ = _e359.xyz;
-    let _e361 = output_color;
-    _ = _e361.xyz;
+    let _e351 = emissive;
+    let _e353 = output_color;
+    let _e356 = (_e349.xyz + (_e351.xyz * _e353.w));
+    output_color.x = _e356.x;
+    output_color.y = _e356.y;
+    output_color.z = _e356.z;
     let _e363 = output_color;
-    let _e365 = reinhard_luminance(_e363.xyz);
-    output_color.x = _e365.x;
-    output_color.y = _e365.y;
-    output_color.z = _e365.z;
-    let _e372 = output_color;
-    o_Target = _e372;
+    _ = _e363.xyz;
+    let _e365 = output_color;
+    _ = _e365.xyz;
+    let _e367 = output_color;
+    let _e369 = reinhard_luminance(_e367.xyz);
+    output_color.x = _e369.x;
+    output_color.y = _e369.y;
+    output_color.z = _e369.z;
+    let _e376 = output_color;
+    o_Target = _e376;
     return;
 }
 
diff --git a/tests/out/wgsl/operators.wgsl b/tests/out/wgsl/operators.wgsl
index 2aa21785e1..fc5cf574b5 100644
--- a/tests/out/wgsl/operators.wgsl
+++ b/tests/out/wgsl/operators.wgsl
@@ -52,10 +52,23 @@ fn constructors() -> f32 {
 }
 
 fn logical() {
+    var local: bool;
+    var local_1: bool;
+
     _ = !(true);
     _ = !(vec2<bool>(true));
-    _ = (true || false);
-    _ = (true && false);
+    if true {
+        local = true;
+    } else {
+        local = false;
+    }
+    _ = local;
+    if true {
+        local_1 = false;
+    } else {
+        local_1 = false;
+    }
+    _ = local_1;
     _ = (true | false);
     _ = (vec3<bool>(true) | vec3<bool>(false));
     _ = (true & false);
diff --git a/tests/out/wgsl/short_circuit-frag.wgsl b/tests/out/wgsl/short_circuit-frag.wgsl
new file mode 100644
index 0000000000..fcdf5b4338
--- /dev/null
+++ b/tests/out/wgsl/short_circuit-frag.wgsl
@@ -0,0 +1,91 @@
+fn a() -> bool {
+    return true;
+}
+
+fn b() -> bool {
+    return true;
+}
+
+fn c() -> bool {
+    return true;
+}
+
+fn d() -> bool {
+    return true;
+}
+
+fn main_1() {
+    var local: bool;
+    var local_1: bool;
+    var out1_: bool;
+    var local_2: bool;
+    var local_3: bool;
+    var out2_: bool;
+    var local_4: bool;
+    var local_5: bool;
+    var local_6: bool;
+    var out3_: bool;
+
+    let _e0 = a();
+    if _e0 {
+        local = true;
+    } else {
+        let _e1 = b();
+        local = _e1;
+    }
+    let _e4 = local;
+    if _e4 {
+        local_1 = true;
+    } else {
+        let _e5 = c();
+        local_1 = _e5;
+    }
+    let _e8 = local_1;
+    out1_ = _e8;
+    let _e10 = a();
+    if _e10 {
+        let _e11 = b();
+        local_2 = _e11;
+    } else {
+        local_2 = false;
+    }
+    let _e14 = local_2;
+    if _e14 {
+        let _e15 = c();
+        local_3 = _e15;
+    } else {
+        local_3 = false;
+    }
+    let _e18 = local_3;
+    out2_ = _e18;
+    let _e20 = a();
+    if _e20 {
+        local_4 = true;
+    } else {
+        let _e21 = b();
+        local_4 = _e21;
+    }
+    let _e24 = local_4;
+    if _e24 {
+        let _e25 = c();
+        if _e25 {
+            local_5 = true;
+        } else {
+            let _e26 = d();
+            local_5 = _e26;
+        }
+        let _e29 = local_5;
+        local_6 = _e29;
+    } else {
+        local_6 = false;
+    }
+    let _e32 = local_6;
+    out3_ = _e32;
+    return;
+}
+
+@fragment 
+fn main() {
+    main_1();
+    return;
+}
diff --git a/tests/out/wgsl/short_circuit.wgsl b/tests/out/wgsl/short_circuit.wgsl
new file mode 100644
index 0000000000..7a2e872918
--- /dev/null
+++ b/tests/out/wgsl/short_circuit.wgsl
@@ -0,0 +1,79 @@
+fn a() -> bool {
+    return true;
+}
+
+fn b() -> bool {
+    return true;
+}
+
+fn c() -> bool {
+    return true;
+}
+
+fn d() -> bool {
+    return true;
+}
+
+@compute @workgroup_size(1, 1, 1) 
+fn main() {
+    var local: bool;
+    var local_1: bool;
+    var local_2: bool;
+    var local_3: bool;
+    var local_4: bool;
+    var local_5: bool;
+    var local_6: bool;
+
+    let _e0 = a();
+    if _e0 {
+        local = true;
+    } else {
+        let _e1 = b();
+        local = _e1;
+    }
+    let _e4 = local;
+    if _e4 {
+        local_1 = true;
+    } else {
+        let _e5 = c();
+        local_1 = _e5;
+    }
+    _ = local_1;
+    let _e9 = a();
+    if _e9 {
+        let _e10 = b();
+        local_2 = _e10;
+    } else {
+        local_2 = false;
+    }
+    let _e13 = local_2;
+    if _e13 {
+        let _e14 = c();
+        local_3 = _e14;
+    } else {
+        local_3 = false;
+    }
+    _ = local_3;
+    let _e18 = a();
+    if _e18 {
+        local_4 = true;
+    } else {
+        let _e19 = b();
+        local_4 = _e19;
+    }
+    let _e22 = local_4;
+    if _e22 {
+        let _e23 = c();
+        if _e23 {
+            local_5 = true;
+        } else {
+            let _e24 = d();
+            local_5 = _e24;
+        }
+        let _e27 = local_5;
+        local_6 = _e27;
+    } else {
+        local_6 = false;
+    }
+    _ = local_6;
+}
diff --git a/tests/snapshots.rs b/tests/snapshots.rs
index d7837e34f0..4fe308e0c4 100644
--- a/tests/snapshots.rs
+++ b/tests/snapshots.rs
@@ -476,6 +476,10 @@ fn convert_wgsl() {
             "operators",
             Targets::SPIRV | Targets::METAL | Targets::GLSL | Targets::HLSL | Targets::WGSL,
         ),
+        (
+            "short_circuit",
+            Targets::SPIRV | Targets::METAL | Targets::GLSL | Targets::HLSL | Targets::WGSL,
+        ),
         (
             "functions",
             Targets::SPIRV | Targets::METAL | Targets::GLSL | Targets::HLSL | Targets::WGSL,