Commit `2a4e06bcb3`

mlugg <mlugg@mlugg.co.uk>

2025-03-10 04:31:36

Sema: rewrite comptime arithmetic

This commit reworks how Sema handles arithmetic on comptime-known values, fixing many bugs in the process. The general pattern is that arithmetic on comptime-known values is now handled by the new namespace `Sema.arith`. Functions handling comptime arithmetic no longer live on `Value`; this is because some of them can emit compile errors, so some *can't* go on `Value`. Only semantic analysis should really be doing arithmetic on `Value`s anyway, so it makes sense for it to integrate more tightly with `Sema`. This commit also implements more coherent rules surrounding how `undefined` interacts with comptime and mixed-comptime-runtime arithmetic. The rules are as follows. * If an operation cannot trigger Illegal Behavior, and any operand is `undefined`, the result is `undefined`. This includes operations like `0 *| undef`, where the LHS logically *could* be used to determine a defined result. This is partly to simplify the language, but mostly to permit codegen backends to represent `undefined` values as completely invalid states. * If an operation *can* trigger Illegal Behvaior, and any operand is `undefined`, then Illegal Behavior results. This occurs even if the operand in question isn't the one that "decides" illegal behavior; for instance, `undef / 1` is undefined. This is for the same reasons as described above. * An operation which would trigger Illegal Behavior, when evaluated at comptime, instead triggers a compile error. Additionally, if one operand is comptime-known undef, such that the other (runtime-known) operand isn't needed to determine that Illegal Behavior would occur, the compile error is triggered. * The only situation in which an operation with one comptime-known operand has a comptime-known result is if that operand is undefined, in which case the result is either undefined or a compile error per the above rules. This could potentially be loosened in future (for instance, `0 * rt` could be comptime-known 0 with a runtime assertion that `rt` is not undefined), but at least for now, defining it more conservatively simplifies the language and allows us to easily change this in future if desired. This commit fixes many bugs regarding the handling of `undefined`, particularly in vectors. Along with a collection of smaller tests, two very large test cases are added to check arithmetic on `undefined`. The operations which have been rewritten in this PR are: * `+`, `+%`, `+|`, `@addWithOverflow` * `-`, `-%`, `-|`, `@subWithOverflow` * `*`, `*%`, `*|`, `@mulWithOverflow` * `/`, `@divFloor`, `@divTrunc`, `@divExact` * `%`, `@rem`, `@mod` Other arithmetic operations are currently unchanged. Resolves: #22743 Resolves: #22745 Resolves: #22748 Resolves: #22749 Resolves: #22914

master

1 parent aa3db7c

@@ -0,0 +1,1609 @@
+//! This file encapsules all arithmetic operations on comptime-known integers, floats, and vectors.
+//!
+//! It is only used in cases where both operands are comptime-known; a single comptime-known operand
+//! is handled directly by `Sema.zig`.
+//!
+//! Functions starting with `int`, `comptimeInt`, or `float` are low-level primitives which operate
+//! on defined scalar values; generally speaking, they are at the bottom of this file and non-`pub`.
+
+/// Asserts that `ty` is a scalar integer type, and that `prev_val` is of type `ty`.
+/// Returns a value one greater than `prev_val`. If this would overflow `ty,` then the
+/// return value has `overflow` set, and `val` is instead a `comptime_int`.
+pub fn incrementDefinedInt(
+    sema: *Sema,
+    ty: Type,
+    prev_val: Value,
+) CompileError!struct { overflow: bool, val: Value } {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    assert(prev_val.typeOf(zcu).toIntern() == ty.toIntern());
+    assert(!prev_val.isUndef(zcu));
+    const res = try intAdd(sema, prev_val, try pt.intValue(ty, 1), ty);
+    return .{ .overflow = res.overflow, .val = res.val };
+}
+
+/// `val` is of type `ty`.
+/// `ty` is a float, comptime_float, or vector thereof.
+pub fn negateFloat(
+    sema: *Sema,
+    ty: Type,
+    val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    if (val.isUndef(zcu)) return val;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const scalar_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+            const result_elems = try sema.arena.alloc(InternPool.Index, len);
+            for (result_elems, 0..) |*result_elem, elem_idx| {
+                const elem = try val.elemValue(pt, elem_idx);
+                if (elem.isUndef(zcu)) {
+                    result_elem.* = elem.toIntern();
+                } else {
+                    result_elem.* = (try floatNeg(sema, elem, scalar_ty)).toIntern();
+                }
+            }
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = result_elems },
+            } });
+            return .fromInterned(result_val);
+        },
+        .float, .comptime_float => return floatNeg(sema, val, ty),
+        else => unreachable,
+    }
+}
+
+/// Wraps on integers, but accepts floats.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, float, comptime_int, or comptime_float; *not* a vector.
+pub fn addMaybeWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value {
+    const zcu = sema.pt.zcu;
+    if (lhs.isUndef(zcu)) return lhs;
+    if (lhs.isUndef(zcu)) return rhs;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return (try intAddWithOverflow(sema, lhs, rhs, ty)).wrapped_result,
+        .float, .comptime_float => return floatAdd(sema, lhs, rhs, ty),
+        else => unreachable,
+    }
+}
+
+/// Wraps on integers, but accepts floats.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, float, comptime_int, or comptime_float; *not* a vector.
+pub fn subMaybeWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value {
+    const zcu = sema.pt.zcu;
+    if (lhs.isUndef(zcu)) return lhs;
+    if (lhs.isUndef(zcu)) return rhs;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return (try intSubWithOverflow(sema, lhs, rhs, ty)).wrapped_result,
+        .float, .comptime_float => return floatSub(sema, lhs, rhs, ty),
+        else => unreachable,
+    }
+}
+
+/// Wraps on integers, but accepts floats.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, float, comptime_int, or comptime_float; *not* a vector.
+pub fn mulMaybeWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value {
+    const zcu = sema.pt.zcu;
+    if (lhs.isUndef(zcu)) return lhs;
+    if (lhs.isUndef(zcu)) return rhs;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return (try intMulWithOverflow(sema, lhs, rhs, ty)).wrapped_result,
+        .float, .comptime_float => return floatMul(sema, lhs, rhs, ty),
+        else => unreachable,
+    }
+}
+
+/// `lhs` and `rhs` are of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn addWithOverflow(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return addWithOverflowScalar(sema, ty, lhs, rhs),
+        .vector => {
+            const scalar_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+            switch (scalar_ty.zigTypeTag(zcu)) {
+                .int, .comptime_int => {},
+                else => unreachable,
+            }
+            const overflow_bits = try sema.arena.alloc(InternPool.Index, len);
+            const wrapped_results = try sema.arena.alloc(InternPool.Index, len);
+            for (overflow_bits, wrapped_results, 0..) |*ob, *wr, elem_idx| {
+                const lhs_elem = try lhs.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs.elemValue(pt, elem_idx);
+                const elem_result = try addWithOverflowScalar(sema, scalar_ty, lhs_elem, rhs_elem);
+                ob.* = elem_result.overflow_bit.toIntern();
+                wr.* = elem_result.wrapped_result.toIntern();
+            }
+            return .{
+                .overflow_bit = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = (try pt.vectorType(.{ .len = len, .child = .u1_type })).toIntern(),
+                    .storage = .{ .elems = overflow_bits },
+                } })),
+                .wrapped_result = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = ty.toIntern(),
+                    .storage = .{ .elems = wrapped_results },
+                } })),
+            };
+        },
+        else => unreachable,
+    }
+}
+fn addWithOverflowScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => {},
+        else => unreachable,
+    }
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return .{
+        .overflow_bit = try pt.undefValue(.u1),
+        .wrapped_result = try pt.undefValue(ty),
+    };
+    return intAddWithOverflow(sema, lhs, rhs, ty);
+}
+
+/// `lhs` and `rhs` are of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn subWithOverflow(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return subWithOverflowScalar(sema, ty, lhs, rhs),
+        .vector => {
+            const scalar_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+            switch (scalar_ty.zigTypeTag(zcu)) {
+                .int, .comptime_int => {},
+                else => unreachable,
+            }
+            const overflow_bits = try sema.arena.alloc(InternPool.Index, len);
+            const wrapped_results = try sema.arena.alloc(InternPool.Index, len);
+            for (overflow_bits, wrapped_results, 0..) |*ob, *wr, elem_idx| {
+                const lhs_elem = try lhs.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs.elemValue(pt, elem_idx);
+                const elem_result = try subWithOverflowScalar(sema, scalar_ty, lhs_elem, rhs_elem);
+                ob.* = elem_result.overflow_bit.toIntern();
+                wr.* = elem_result.wrapped_result.toIntern();
+            }
+            return .{
+                .overflow_bit = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = (try pt.vectorType(.{ .len = len, .child = .u1_type })).toIntern(),
+                    .storage = .{ .elems = overflow_bits },
+                } })),
+                .wrapped_result = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = ty.toIntern(),
+                    .storage = .{ .elems = wrapped_results },
+                } })),
+            };
+        },
+        else => unreachable,
+    }
+}
+fn subWithOverflowScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => {},
+        else => unreachable,
+    }
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return .{
+        .overflow_bit = try pt.undefValue(.u1),
+        .wrapped_result = try pt.undefValue(ty),
+    };
+    return intSubWithOverflow(sema, lhs, rhs, ty);
+}
+
+/// `lhs` and `rhs` are of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn mulWithOverflow(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => return mulWithOverflowScalar(sema, ty, lhs, rhs),
+        .vector => {
+            const scalar_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+            switch (scalar_ty.zigTypeTag(zcu)) {
+                .int, .comptime_int => {},
+                else => unreachable,
+            }
+            const overflow_bits = try sema.arena.alloc(InternPool.Index, len);
+            const wrapped_results = try sema.arena.alloc(InternPool.Index, len);
+            for (overflow_bits, wrapped_results, 0..) |*ob, *wr, elem_idx| {
+                const lhs_elem = try lhs.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs.elemValue(pt, elem_idx);
+                const elem_result = try mulWithOverflowScalar(sema, scalar_ty, lhs_elem, rhs_elem);
+                ob.* = elem_result.overflow_bit.toIntern();
+                wr.* = elem_result.wrapped_result.toIntern();
+            }
+            return .{
+                .overflow_bit = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = (try pt.vectorType(.{ .len = len, .child = .u1_type })).toIntern(),
+                    .storage = .{ .elems = overflow_bits },
+                } })),
+                .wrapped_result = .fromInterned(try pt.intern(.{ .aggregate = .{
+                    .ty = ty.toIntern(),
+                    .storage = .{ .elems = wrapped_results },
+                } })),
+            };
+        },
+        else => unreachable,
+    }
+}
+fn mulWithOverflowScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs: Value,
+    rhs: Value,
+) CompileError!Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => {},
+        else => unreachable,
+    }
+    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return .{
+        .overflow_bit = try pt.undefValue(.u1),
+        .wrapped_result = try pt.undefValue(ty),
+    };
+    return intMulWithOverflow(sema, lhs, rhs, ty);
+}
+
+/// Applies the `+` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, float, comptime_int, comptime_float, or vector.
+pub fn add(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try addScalar(sema, block, elem_ty, lhs_elem, rhs_elem, src, lhs_src, rhs_src, elem_idx)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return addScalar(sema, block, ty, lhs_val, rhs_val, src, lhs_src, rhs_src, null),
+    }
+}
+fn addScalar(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    vec_idx: ?usize,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_int = switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
+
+    if (is_int) {
+        if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        const res = try intAdd(sema, lhs_val, rhs_val, ty);
+        if (res.overflow) return sema.failWithIntegerOverflow(block, src, ty, res.val, vec_idx);
+        return res.val;
+    } else {
+        if (lhs_val.isUndef(zcu)) return lhs_val;
+        if (rhs_val.isUndef(zcu)) return rhs_val;
+        return floatAdd(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+/// Applies the `+%` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn addWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try addWrapScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return addWrapScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn addWrapScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    return (try addWithOverflowScalar(sema, ty, lhs_val, rhs_val)).wrapped_result;
+}
+
+/// Applies the `+|` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn addSat(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try addSatScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return addSatScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn addSatScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_comptime_int = switch (ty.zigTypeTag(zcu)) {
+        .int => false,
+        .comptime_int => true,
+        else => unreachable,
+    };
+    if (lhs_val.isUndef(zcu)) return lhs_val;
+    if (rhs_val.isUndef(zcu)) return rhs_val;
+    if (is_comptime_int) {
+        const res = try intAdd(sema, lhs_val, rhs_val, ty);
+        assert(!res.overflow);
+        return res.val;
+    } else {
+        return intAddSat(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+/// Applies the `-` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, float, comptime_int, comptime_float, or vector.
+pub fn sub(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try subScalar(sema, block, elem_ty, lhs_elem, rhs_elem, src, lhs_src, rhs_src, elem_idx)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return subScalar(sema, block, ty, lhs_val, rhs_val, src, lhs_src, rhs_src, null),
+    }
+}
+fn subScalar(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    vec_idx: ?usize,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_int = switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
+
+    if (is_int) {
+        if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        const res = try intSub(sema, lhs_val, rhs_val, ty);
+        if (res.overflow) return sema.failWithIntegerOverflow(block, src, ty, res.val, vec_idx);
+        return res.val;
+    } else {
+        if (lhs_val.isUndef(zcu)) return lhs_val;
+        if (rhs_val.isUndef(zcu)) return rhs_val;
+        return floatSub(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+/// Applies the `-%` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn subWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try subWrapScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return subWrapScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn subWrapScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => {},
+        else => unreachable,
+    }
+    if (lhs_val.isUndef(zcu)) return lhs_val;
+    if (rhs_val.isUndef(zcu)) return rhs_val;
+    const result = try intSubWithOverflow(sema, lhs_val, rhs_val, ty);
+    return result.wrapped_result;
+}
+
+/// Applies the `-|` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn subSat(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try subSatScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return subSatScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn subSatScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_comptime_int = switch (ty.zigTypeTag(zcu)) {
+        .int => false,
+        .comptime_int => true,
+        else => unreachable,
+    };
+    if (lhs_val.isUndef(zcu)) return lhs_val;
+    if (rhs_val.isUndef(zcu)) return rhs_val;
+    if (is_comptime_int) {
+        const res = try intSub(sema, lhs_val, rhs_val, ty);
+        assert(!res.overflow);
+        return res.val;
+    } else {
+        return intSubSat(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+/// Applies the `*` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are fully-resolved values of type `ty`.
+/// `ty` is an int, float, comptime_int, comptime_float, or vector.
+pub fn mul(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try mulScalar(sema, block, elem_ty, lhs_elem, rhs_elem, src, lhs_src, rhs_src, elem_idx)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return mulScalar(sema, block, ty, lhs_val, rhs_val, src, lhs_src, rhs_src, null),
+    }
+}
+fn mulScalar(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    vec_idx: ?usize,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_int = switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
+
+    if (is_int) {
+        if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        const res = try intMul(sema, lhs_val, rhs_val, ty);
+        if (res.overflow) return sema.failWithIntegerOverflow(block, src, ty, res.val, vec_idx);
+        return res.val;
+    } else {
+        if (lhs_val.isUndef(zcu)) return lhs_val;
+        if (rhs_val.isUndef(zcu)) return rhs_val;
+        return floatMul(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+/// Applies the `*%` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn mulWrap(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try mulWrapScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return mulWrapScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn mulWrapScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => {},
+        else => unreachable,
+    }
+    if (lhs_val.isUndef(zcu)) return lhs_val;
+    if (rhs_val.isUndef(zcu)) return rhs_val;
+    const result = try intMulWithOverflow(sema, lhs_val, rhs_val, ty);
+    return result.wrapped_result;
+}
+
+/// Applies the `*|` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are both of type `ty`.
+/// `ty` is an int, comptime_int, or vector thereof.
+pub fn mulSat(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try mulSatScalar(sema, elem_ty, lhs_elem, rhs_elem)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return mulSatScalar(sema, ty, lhs_val, rhs_val),
+    }
+}
+fn mulSatScalar(
+    sema: *Sema,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_comptime_int = switch (ty.zigTypeTag(zcu)) {
+        .int => false,
+        .comptime_int => true,
+        else => unreachable,
+    };
+    if (lhs_val.isUndef(zcu)) return lhs_val;
+    if (rhs_val.isUndef(zcu)) return rhs_val;
+    if (is_comptime_int) {
+        const res = try intMul(sema, lhs_val, rhs_val, ty);
+        assert(!res.overflow);
+        return res.val;
+    } else {
+        return intMulSat(sema, lhs_val, rhs_val, ty);
+    }
+}
+
+pub const DivOp = enum { div, div_trunc, div_floor, div_exact };
+
+/// Applies the `/` operator to comptime-known values.
+/// `lhs_val` and `rhs_val` are fully-resolved values of type `ty`.
+/// `ty` is an int, float, comptime_int, comptime_float, or vector.
+pub fn div(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    op: DivOp,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try divScalar(sema, block, elem_ty, lhs_elem, rhs_elem, src, lhs_src, rhs_src, op, elem_idx)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return divScalar(sema, block, ty, lhs_val, rhs_val, src, lhs_src, rhs_src, op, null),
+    }
+}
+fn divScalar(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    src: LazySrcLoc,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    op: DivOp,
+    vec_idx: ?usize,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_int = switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
+
+    if (is_int) {
+        if (rhs_val.eqlScalarNum(.zero_comptime_int, zcu)) return sema.failWithDivideByZero(block, rhs_src);
+
+        if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+
+        switch (op) {
+            .div, .div_trunc => {
+                const res = try intDivTrunc(sema, lhs_val, rhs_val, ty);
+                if (res.overflow) return sema.failWithIntegerOverflow(block, src, ty, res.val, vec_idx);
+                return res.val;
+            },
+            .div_floor => {
+                const res = try intDivFloor(sema, lhs_val, rhs_val, ty);
+                if (res.overflow) return sema.failWithIntegerOverflow(block, src, ty, res.val, vec_idx);
+                return res.val;
+            },
+            .div_exact => switch (try intDivExact(sema, lhs_val, rhs_val, ty)) {
+                .remainder => return sema.fail(block, src, "exact division produced remainder", .{}),
+                .overflow => |val| return sema.failWithIntegerOverflow(block, src, ty, val, vec_idx),
+                .success => |val| return val,
+            },
+        }
+    } else {
+        const allow_div_zero = switch (op) {
+            .div, .div_trunc, .div_floor => ty.toIntern() != .comptime_float_type and block.float_mode == .strict,
+            .div_exact => false,
+        };
+        if (!allow_div_zero) {
+            if (rhs_val.eqlScalarNum(.zero_comptime_int, zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+
+        const can_exhibit_ib = !allow_div_zero or op == .div_exact;
+        if (can_exhibit_ib) {
+            if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+            if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        } else {
+            if (lhs_val.isUndef(zcu)) return lhs_val;
+            if (rhs_val.isUndef(zcu)) return rhs_val;
+        }
+
+        switch (op) {
+            .div => return floatDiv(sema, lhs_val, rhs_val, ty),
+            .div_trunc => return floatDivTrunc(sema, lhs_val, rhs_val, ty),
+            .div_floor => return floatDivFloor(sema, lhs_val, rhs_val, ty),
+            .div_exact => {
+                if (!floatDivIsExact(sema, lhs_val, rhs_val, ty)) {
+                    return sema.fail(block, src, "exact division produced remainder", .{});
+                }
+                return floatDivTrunc(sema, lhs_val, rhs_val, ty);
+            },
+        }
+    }
+}
+
+pub const ModRemOp = enum { mod, rem };
+
+/// Applies `@mod` or `@rem` to comptime-known values.
+/// `lhs_val` and `rhs_val` are fully-resolved values of type `ty`.
+/// `ty` is an int, float, comptime_int, comptime_float, or vector.
+pub fn modRem(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    op: ModRemOp,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.zigTypeTag(zcu)) {
+        .vector => {
+            const elem_ty = ty.childType(zcu);
+            const len = ty.vectorLen(zcu);
+
+            const elem_vals = try sema.arena.alloc(InternPool.Index, len);
+            for (elem_vals, 0..) |*result_elem, elem_idx| {
+                const lhs_elem = try lhs_val.elemValue(pt, elem_idx);
+                const rhs_elem = try rhs_val.elemValue(pt, elem_idx);
+                result_elem.* = (try modRemScalar(sema, block, elem_ty, lhs_elem, rhs_elem, lhs_src, rhs_src, op, elem_idx)).toIntern();
+            }
+
+            const result_val = try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = elem_vals },
+            } });
+            return .fromInterned(result_val);
+        },
+        else => return modRemScalar(sema, block, ty, lhs_val, rhs_val, lhs_src, rhs_src, op, null),
+    }
+}
+fn modRemScalar(
+    sema: *Sema,
+    block: *Block,
+    ty: Type,
+    lhs_val: Value,
+    rhs_val: Value,
+    lhs_src: LazySrcLoc,
+    rhs_src: LazySrcLoc,
+    op: ModRemOp,
+    vec_idx: ?usize,
+) CompileError!Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const is_int = switch (ty.zigTypeTag(zcu)) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
+
+    _ = vec_idx; // TODO: use this in the "use of undefined" error
+
+    const allow_div_zero = !is_int and block.float_mode == .strict;
+    if (allow_div_zero) {
+        if (lhs_val.isUndef(zcu)) return lhs_val;
+        if (rhs_val.isUndef(zcu)) return rhs_val;
+    } else {
+        if (lhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        if (rhs_val.isUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        if (rhs_val.eqlScalarNum(.zero_comptime_int, zcu)) return sema.failWithDivideByZero(block, rhs_src);
+    }
+
+    if (is_int) {
+        switch (op) {
+            .mod => return intMod(sema, lhs_val, rhs_val, ty),
+            .rem => return intRem(sema, lhs_val, rhs_val, ty),
+        }
+    } else {
+        switch (op) {
+            .mod => return floatMod(sema, lhs_val, rhs_val, ty),
+            .rem => return floatRem(sema, lhs_val, rhs_val, ty),
+        }
+    }
+}
+
+/// If the value overflowed the type, returns a comptime_int instead.
+/// Only supports scalars.
+fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !struct { overflow: bool, val: Value } {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{ .overflow = false, .val = try comptimeIntAdd(sema, lhs, rhs) },
+        else => {
+            const res = try intAddWithOverflowInner(sema, lhs, rhs, ty);
+            return switch (res.overflow_bit.toUnsignedInt(zcu)) {
+                0 => .{ .overflow = false, .val = res.wrapped_result },
+                1 => .{ .overflow = true, .val = try comptimeIntAdd(sema, lhs, rhs) },
+                else => unreachable,
+            };
+        },
+    }
+}
+/// Add two integers, returning a `comptime_int` regardless of the input types.
+fn comptimeIntAdd(sema: *Sema, lhs: Value, rhs: Value) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.add(lhs_bigint, rhs_bigint);
+    return pt.intValue_big(.comptime_int, result_bigint.toConst());
+}
+fn intAddWithOverflow(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{
+            .overflow_bit = try sema.pt.intValue(.u1, 0),
+            .wrapped_result = try comptimeIntAdd(sema, lhs, rhs),
+        },
+        else => return intAddWithOverflowInner(sema, lhs, rhs, ty),
+    }
+}
+/// Like `intAddWithOverflow`, but asserts that `ty` is not `Type.comptime_int`.
+fn intAddWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    assert(ty.toIntern() != .comptime_int_type);
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcTwosCompLimbCount(info.bits),
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    const overflowed = result_bigint.addWrap(lhs_bigint, rhs_bigint, info.signedness, info.bits);
+    return .{
+        .overflow_bit = try pt.intValue(.u1, @intFromBool(overflowed)),
+        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
+    };
+}
+fn intAddSat(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcTwosCompLimbCount(info.bits),
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.addSat(lhs_bigint, rhs_bigint, info.signedness, info.bits);
+    return pt.intValue_big(ty, result_bigint.toConst());
+}
+
+/// If the value overflowed the type, returns a comptime_int instead.
+/// Only supports scalars.
+fn intSub(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !struct { overflow: bool, val: Value } {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{ .overflow = false, .val = try comptimeIntSub(sema, lhs, rhs) },
+        else => {
+            const res = try intSubWithOverflowInner(sema, lhs, rhs, ty);
+            return switch (res.overflow_bit.toUnsignedInt(zcu)) {
+                0 => .{ .overflow = false, .val = res.wrapped_result },
+                1 => .{ .overflow = true, .val = try comptimeIntSub(sema, lhs, rhs) },
+                else => unreachable,
+            };
+        },
+    }
+}
+/// Subtract two integers, returning a `comptime_int` regardless of the input types.
+fn comptimeIntSub(sema: *Sema, lhs: Value, rhs: Value) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.sub(lhs_bigint, rhs_bigint);
+    return pt.intValue_big(.comptime_int, result_bigint.toConst());
+}
+fn intSubWithOverflow(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{
+            .overflow_bit = try sema.pt.intValue(.u1, 0),
+            .wrapped_result = try comptimeIntSub(sema, lhs, rhs),
+        },
+        else => return intSubWithOverflowInner(sema, lhs, rhs, ty),
+    }
+}
+/// Like `intSubWithOverflow`, but asserts that `ty` is not `Type.comptime_int`.
+fn intSubWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    assert(ty.toIntern() != .comptime_int_type);
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcTwosCompLimbCount(info.bits),
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    const overflowed = result_bigint.subWrap(lhs_bigint, rhs_bigint, info.signedness, info.bits);
+    return .{
+        .overflow_bit = try pt.intValue(.u1, @intFromBool(overflowed)),
+        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
+    };
+}
+fn intSubSat(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcTwosCompLimbCount(info.bits),
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.subSat(lhs_bigint, rhs_bigint, info.signedness, info.bits);
+    return pt.intValue_big(ty, result_bigint.toConst());
+}
+
+/// If the value overflowed the type, returns a comptime_int instead.
+/// Only supports scalars.
+fn intMul(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !struct { overflow: bool, val: Value } {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{ .overflow = false, .val = try comptimeIntMul(sema, lhs, rhs) },
+        else => {
+            const res = try intMulWithOverflowInner(sema, lhs, rhs, ty);
+            return switch (res.overflow_bit.toUnsignedInt(zcu)) {
+                0 => .{ .overflow = false, .val = res.wrapped_result },
+                1 => .{ .overflow = true, .val = try comptimeIntMul(sema, lhs, rhs) },
+                else => unreachable,
+            };
+        },
+    }
+}
+/// Multiply two integers, returning a `comptime_int` regardless of the input types.
+fn comptimeIntMul(sema: *Sema, lhs: Value, rhs: Value) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len + rhs_bigint.limbs.len,
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    const limbs_buffer = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
+    );
+    result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, sema.arena);
+    return pt.intValue_big(.comptime_int, result_bigint.toConst());
+}
+fn intMulWithOverflow(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    switch (ty.toIntern()) {
+        .comptime_int_type => return .{
+            .overflow_bit = try sema.pt.intValue(.u1, 0),
+            .wrapped_result = try comptimeIntMul(sema, lhs, rhs),
+        },
+        else => return intMulWithOverflowInner(sema, lhs, rhs, ty),
+    }
+}
+/// Like `intMulWithOverflow`, but asserts that `ty` is not `Type.comptime_int`.
+fn intMulWithOverflowInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value.OverflowArithmeticResult {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
+    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len + rhs_bigint.limbs.len,
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.mulNoAlias(lhs_bigint, rhs_bigint, sema.arena);
+    const overflowed = !result_bigint.toConst().fitsInTwosComp(info.signedness, info.bits);
+    if (overflowed) result_bigint.truncate(result_bigint.toConst(), info.signedness, info.bits);
+    return .{
+        .overflow_bit = try pt.intValue(.u1, @intFromBool(overflowed)),
+        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
+    };
+}
+fn intMulSat(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len + rhs_bigint.limbs.len,
+    );
+    var result_bigint: BigIntMutable = .{ .limbs = limbs, .positive = undefined, .len = undefined };
+    result_bigint.mulNoAlias(lhs_bigint, rhs_bigint, sema.arena);
+    result_bigint.saturate(result_bigint.toConst(), info.signedness, info.bits);
+    return pt.intValue_big(ty, result_bigint.toConst());
+}
+fn intDivTrunc(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !struct { overflow: bool, val: Value } {
+    const result = intDivTruncInner(sema, lhs, rhs, ty) catch |err| switch (err) {
+        error.Overflow => {
+            const result = intDivTruncInner(sema, lhs, rhs, .comptime_int) catch |err1| switch (err1) {
+                error.Overflow => unreachable,
+                else => |e| return e,
+            };
+            return .{ .overflow = true, .val = result };
+        },
+        else => |e| return e,
+    };
+    return .{ .overflow = false, .val = result };
+}
+fn intDivTruncInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs_q = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        std.math.big.Limb,
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buf = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q: BigIntMutable = .{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r: BigIntMutable = .{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buf);
+    if (ty.toIntern() != .comptime_int_type) {
+        const info = ty.intInfo(zcu);
+        if (!result_q.toConst().fitsInTwosComp(info.signedness, info.bits)) {
+            return error.Overflow;
+        }
+    }
+    return pt.intValue_big(ty, result_q.toConst());
+}
+fn intDivExact(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !union(enum) {
+    remainder,
+    overflow: Value,
+    success: Value,
+} {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs_q = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        std.math.big.Limb,
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buf = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q: BigIntMutable = .{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r: BigIntMutable = .{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buf);
+    if (!result_r.toConst().eqlZero()) {
+        return .remainder;
+    }
+    if (ty.toIntern() != .comptime_int_type) {
+        const info = ty.intInfo(zcu);
+        if (!result_q.toConst().fitsInTwosComp(info.signedness, info.bits)) {
+            return .{ .overflow = try pt.intValue_big(.comptime_int, result_q.toConst()) };
+        }
+    }
+    return .{ .success = try pt.intValue_big(ty, result_q.toConst()) };
+}
+fn intDivFloor(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !struct { overflow: bool, val: Value } {
+    const result = intDivFloorInner(sema, lhs, rhs, ty) catch |err| switch (err) {
+        error.Overflow => {
+            const result = intDivFloorInner(sema, lhs, rhs, .comptime_int) catch |err1| switch (err1) {
+                error.Overflow => unreachable,
+                else => |e| return e,
+            };
+            return .{ .overflow = true, .val = result };
+        },
+        else => |e| return e,
+    };
+    return .{ .overflow = false, .val = result };
+}
+fn intDivFloorInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs_q = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        std.math.big.Limb,
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buf = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q: BigIntMutable = .{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r: BigIntMutable = .{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divFloor(&result_r, lhs_bigint, rhs_bigint, limbs_buf);
+    if (ty.toIntern() != .comptime_int_type) {
+        const info = ty.intInfo(zcu);
+        if (!result_q.toConst().fitsInTwosComp(info.signedness, info.bits)) {
+            return error.Overflow;
+        }
+    }
+    return pt.intValue_big(ty, result_q.toConst());
+}
+fn intMod(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs_q = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        std.math.big.Limb,
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buf = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q: BigIntMutable = .{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r: BigIntMutable = .{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divFloor(&result_r, lhs_bigint, rhs_bigint, limbs_buf);
+    return pt.intValue_big(ty, result_r.toConst());
+}
+fn intRem(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    var lhs_space: Value.BigIntSpace = undefined;
+    var rhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
+    const limbs_q = try sema.arena.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len,
+    );
+    const limbs_r = try sema.arena.alloc(
+        std.math.big.Limb,
+        rhs_bigint.limbs.len,
+    );
+    const limbs_buf = try sema.arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
+    );
+    var result_q: BigIntMutable = .{ .limbs = limbs_q, .positive = undefined, .len = undefined };
+    var result_r: BigIntMutable = .{ .limbs = limbs_r, .positive = undefined, .len = undefined };
+    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buf);
+    return pt.intValue_big(ty, result_r.toConst());
+}
+
+fn floatAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = lhs.toFloat(f16, zcu) + rhs.toFloat(f16, zcu) },
+        32 => .{ .f32 = lhs.toFloat(f32, zcu) + rhs.toFloat(f32, zcu) },
+        64 => .{ .f64 = lhs.toFloat(f64, zcu) + rhs.toFloat(f64, zcu) },
+        80 => .{ .f80 = lhs.toFloat(f80, zcu) + rhs.toFloat(f80, zcu) },
+        128 => .{ .f128 = lhs.toFloat(f128, zcu) + rhs.toFloat(f128, zcu) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatSub(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = lhs.toFloat(f16, zcu) - rhs.toFloat(f16, zcu) },
+        32 => .{ .f32 = lhs.toFloat(f32, zcu) - rhs.toFloat(f32, zcu) },
+        64 => .{ .f64 = lhs.toFloat(f64, zcu) - rhs.toFloat(f64, zcu) },
+        80 => .{ .f80 = lhs.toFloat(f80, zcu) - rhs.toFloat(f80, zcu) },
+        128 => .{ .f128 = lhs.toFloat(f128, zcu) - rhs.toFloat(f128, zcu) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatMul(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = lhs.toFloat(f16, zcu) * rhs.toFloat(f16, zcu) },
+        32 => .{ .f32 = lhs.toFloat(f32, zcu) * rhs.toFloat(f32, zcu) },
+        64 => .{ .f64 = lhs.toFloat(f64, zcu) * rhs.toFloat(f64, zcu) },
+        80 => .{ .f80 = lhs.toFloat(f80, zcu) * rhs.toFloat(f80, zcu) },
+        128 => .{ .f128 = lhs.toFloat(f128, zcu) * rhs.toFloat(f128, zcu) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatDiv(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = lhs.toFloat(f16, zcu) / rhs.toFloat(f16, zcu) },
+        32 => .{ .f32 = lhs.toFloat(f32, zcu) / rhs.toFloat(f32, zcu) },
+        64 => .{ .f64 = lhs.toFloat(f64, zcu) / rhs.toFloat(f64, zcu) },
+        80 => .{ .f80 = lhs.toFloat(f80, zcu) / rhs.toFloat(f80, zcu) },
+        128 => .{ .f128 = lhs.toFloat(f128, zcu) / rhs.toFloat(f128, zcu) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatDivTrunc(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = @divTrunc(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
+        32 => .{ .f32 = @divTrunc(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
+        64 => .{ .f64 = @divTrunc(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
+        80 => .{ .f80 = @divTrunc(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
+        128 => .{ .f128 = @divTrunc(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatDivFloor(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = @divFloor(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
+        32 => .{ .f32 = @divFloor(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
+        64 => .{ .f64 = @divFloor(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
+        80 => .{ .f80 = @divFloor(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
+        128 => .{ .f128 = @divFloor(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatDivIsExact(sema: *Sema, lhs: Value, rhs: Value, ty: Type) bool {
+    const zcu = sema.pt.zcu;
+    const target = zcu.getTarget();
+    return switch (ty.floatBits(target)) {
+        16 => @mod(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) == 0,
+        32 => @mod(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) == 0,
+        64 => @mod(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) == 0,
+        80 => @mod(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) == 0,
+        128 => @mod(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) == 0,
+        else => unreachable,
+    };
+}
+fn floatNeg(sema: *Sema, val: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = -val.toFloat(f16, zcu) },
+        32 => .{ .f32 = -val.toFloat(f32, zcu) },
+        64 => .{ .f64 = -val.toFloat(f64, zcu) },
+        80 => .{ .f80 = -val.toFloat(f80, zcu) },
+        128 => .{ .f128 = -val.toFloat(f128, zcu) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatMod(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = @mod(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
+        32 => .{ .f32 = @mod(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
+        64 => .{ .f64 = @mod(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
+        80 => .{ .f80 = @mod(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
+        128 => .{ .f128 = @mod(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+fn floatRem(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {
+    const pt = sema.pt;
+    const zcu = pt.zcu;
+    const target = zcu.getTarget();
+    const storage: InternPool.Key.Float.Storage = switch (ty.floatBits(target)) {
+        16 => .{ .f16 = @rem(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
+        32 => .{ .f32 = @rem(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
+        64 => .{ .f64 = @rem(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
+        80 => .{ .f80 = @rem(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
+        128 => .{ .f128 = @rem(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
+        else => unreachable,
+    };
+    return .fromInterned(try pt.intern(.{ .float = .{
+        .ty = ty.toIntern(),
+        .storage = storage,
+    } }));
+}
+
+const Sema = @import("../Sema.zig");
+const Block = Sema.Block;
+const InternPool = @import("../InternPool.zig");
+const Type = @import("../Type.zig");
+const Value = @import("../Value.zig");
+const Zcu = @import("../Zcu.zig");
+const CompileError = Zcu.CompileError;
+const LazySrcLoc = Zcu.LazySrcLoc;
+
+const std = @import("std");
+const assert = std.debug.assert;
+const Allocator = std.mem.Allocator;
+const BigIntMutable = std.math.big.int.Mutable;

@@ -188,6 +188,7 @@ const AnalUnit = InternPool.AnalUnit;
 const ComptimeAllocIndex = InternPool.ComptimeAllocIndex;
 const Cache = std.Build.Cache;
 const LowerZon = @import("Sema/LowerZon.zig");
+const arith = @import("Sema/arith.zig");
 
 pub const default_branch_quota = 1000;
 pub const default_reference_trace_len = 2;
@@ -2325,11 +2326,11 @@ fn failWithNeededComptime(sema: *Sema, block: *Block, src: LazySrcLoc, reason: ?
     return sema.failWithOwnedErrorMsg(fail_block, msg);
 }
 
-fn failWithUseOfUndef(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
+pub fn failWithUseOfUndef(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
     return sema.fail(block, src, "use of undefined value here causes undefined behavior", .{});
 }
 
-fn failWithDivideByZero(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
+pub fn failWithDivideByZero(sema: *Sema, block: *Block, src: LazySrcLoc) CompileError {
     return sema.fail(block, src, "division by zero here causes undefined behavior", .{});
 }
 
@@ -2391,22 +2392,15 @@ fn failWithErrorSetCodeMissing(
     });
 }
 
-fn failWithIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc, int_ty: Type, val: Value, vector_index: usize) CompileError {
+pub fn failWithIntegerOverflow(sema: *Sema, block: *Block, src: LazySrcLoc, int_ty: Type, val: Value, vector_index: ?usize) CompileError {
     const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (int_ty.zigTypeTag(zcu) == .vector) {
-        const msg = msg: {
-            const msg = try sema.errMsg(src, "overflow of vector type '{}' with value '{}'", .{
-                int_ty.fmt(pt), val.fmtValueSema(pt, sema),
-            });
-            errdefer msg.destroy(sema.gpa);
-            try sema.errNote(src, msg, "when computing vector element at index '{d}'", .{vector_index});
-            break :msg msg;
-        };
-        return sema.failWithOwnedErrorMsg(block, msg);
-    }
-    return sema.fail(block, src, "overflow of integer type '{}' with value '{}'", .{
-        int_ty.fmt(pt), val.fmtValueSema(pt, sema),
+    return sema.failWithOwnedErrorMsg(block, msg: {
+        const msg = try sema.errMsg(src, "overflow of integer type '{}' with value '{}'", .{
+            int_ty.fmt(pt), val.fmtValueSema(pt, sema),
+        });
+        errdefer msg.destroy(sema.gpa);
+        if (vector_index) |i| try sema.errNote(src, msg, "when computing vector element at index '{d}'", .{i});
+        break :msg msg;
     });
 }
 
@@ -10327,7 +10321,9 @@ fn intCast(
                         .storage = .{ .repeated_elem = one_scalar.toIntern() },
                     } })) else one_scalar;
                     const range_minus_one = try dest_max_val.shl(one, unsigned_operand_ty, sema.arena, pt);
-                    break :range_val try sema.intAdd(range_minus_one, one, unsigned_operand_ty, undefined);
+                    const result = try arith.addWithOverflow(sema, unsigned_operand_ty, range_minus_one, one);
+                    assert(result.overflow_bit.compareAllWithZero(.eq, zcu));
+                    break :range_val result.wrapped_result;
                 } else try pt.getCoerced(dest_max_val, unsigned_operand_ty);
                 const dest_range = Air.internedToRef(dest_range_val.toIntern());
 
@@ -12723,10 +12719,9 @@ fn analyzeSwitchRuntimeBlock(
 
                 while (item.compareScalar(.lte, item_last, operand_ty, zcu)) : ({
                     // Previous validation has resolved any possible lazy values.
-                    item = sema.intAddScalar(item, try pt.intValue(operand_ty, 1), operand_ty) catch |err| switch (err) {
-                        error.Overflow => unreachable,
-                        else => |e| return e,
-                    };
+                    const result = try arith.incrementDefinedInt(sema, operand_ty, item);
+                    assert(!result.overflow);
+                    item = result.val;
                 }) {
                     cases_len += 1;
 
@@ -14183,8 +14178,8 @@ fn zirShl(
     // TODO coerce rhs if air_tag is not shl_sat
     const rhs_is_comptime_int = try sema.checkIntType(block, rhs_src, scalar_rhs_ty);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(rhs);
 
     if (maybe_rhs_val) |rhs_val| {
         if (rhs_val.isUndef(zcu)) {
@@ -14359,8 +14354,8 @@ fn zirShr(
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     const scalar_ty = lhs_ty.scalarType(zcu);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(rhs);
 
     const runtime_src = if (maybe_rhs_val) |rhs_val| rs: {
         if (rhs_val.isUndef(zcu)) {
@@ -14511,8 +14506,8 @@ fn zirBitwise(
     const runtime_src = runtime: {
         // TODO: ask the linker what kind of relocations are available, and
         // in some cases emit a Value that means "this decl's address AND'd with this operand".
-        if (try sema.resolveValueIntable(casted_lhs)) |lhs_val| {
-            if (try sema.resolveValueIntable(casted_rhs)) |rhs_val| {
+        if (try sema.resolveValueResolveLazy(casted_lhs)) |lhs_val| {
+            if (try sema.resolveValueResolveLazy(casted_rhs)) |rhs_val| {
                 const result_val = switch (air_tag) {
                     .bit_and => try lhs_val.bitwiseAnd(rhs_val, resolved_type, sema.arena, pt),
                     .bit_or => try lhs_val.bitwiseOr(rhs_val, resolved_type, sema.arena, pt),
@@ -15289,8 +15284,8 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     if (rhs_scalar_ty.isAnyFloat()) {
         // We handle float negation here to ensure negative zero is represented in the bits.
         if (try sema.resolveValue(rhs)) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) return pt.undefRef(rhs_ty);
-            return Air.internedToRef((try rhs_val.floatNeg(rhs_ty, sema.arena, pt)).toIntern());
+            const result = try arith.negateFloat(sema, rhs_ty, rhs_val);
+            return Air.internedToRef(result.toIntern());
         }
         try sema.requireRuntimeBlock(block, src, null);
         return block.addUnOp(if (block.float_mode == .optimized) .neg_optimized else .neg, rhs);
@@ -15359,24 +15354,22 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
     const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
     const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
 
     const is_int = scalar_tag == .int or scalar_tag == .comptime_int;
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
     if ((lhs_ty.zigTypeTag(zcu) == .comptime_float and rhs_ty.zigTypeTag(zcu) == .comptime_int) or
         (lhs_ty.zigTypeTag(zcu) == .comptime_int and rhs_ty.zigTypeTag(zcu) == .comptime_float))
@@ -15399,92 +15392,38 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     // TODO: emit compile error when .div is used on integers and there would be an
     // ambiguous result between div_floor and div_trunc.
 
-    // For integers:
-    // If the lhs is zero, then zero is returned regardless of rhs.
-    // If the rhs is zero, compile error for division by zero.
-    // If the rhs is undefined, compile error because there is a possible
-    // value (zero) for which the division would be illegal behavior.
-    // If the lhs is undefined:
-    //   * if lhs type is signed:
-    //     * if rhs is comptime-known and not -1, result is undefined
-    //     * if rhs is -1 or runtime-known, compile error because there is a
-    //        possible value (-min_int / -1)  for which division would be
-    //        illegal behavior.
-    //   * if lhs type is unsigned, undef is returned regardless of rhs.
+    // The rules here are like those in `analyzeArithmetic`:
     //
-    // For floats:
-    // If the rhs is zero:
-    //  * comptime_float: compile error for division by zero.
-    //  * other float type:
-    //    * if the lhs is zero: QNaN
-    //    * otherwise: +Inf or -Inf depending on lhs sign
-    // If the rhs is undefined:
-    //  * comptime_float: compile error because there is a possible
-    //    value (zero) for which the division would be illegal behavior.
-    //  * other float type: result is undefined
-    // If the lhs is undefined, result is undefined.
-    switch (scalar_tag) {
-        .int, .comptime_int, .comptime_float => {
-            if (maybe_lhs_val) |lhs_val| {
-                if (!lhs_val.isUndef(zcu)) {
-                    if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        const scalar_zero = switch (scalar_tag) {
-                            .comptime_float, .float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                            .comptime_int, .int => try pt.intValue(resolved_type.scalarType(zcu), 0),
-                            else => unreachable,
-                        };
-                        const zero_val = try sema.splat(resolved_type, scalar_zero);
-                        return Air.internedToRef(zero_val.toIntern());
-                    }
-                }
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                    return sema.failWithDivideByZero(block, rhs_src);
-                }
-                // TODO: if the RHS is one, return the LHS directly
-            }
-        },
-        else => {},
-    }
+    // * If both operands are comptime-known, call the corresponding function in `arith`.
+    //   Inputs which would be IB at runtime are compile errors.
+    //
+    // * Otherwise, if one operand is comptime-known `undefined`, we either trigger a compile error
+    //   or return `undefined`, depending on whether this operator can trigger IB.
+    //
+    // * No other comptime operand determines a comptime result, so remaining cases are runtime ops.
 
-    const runtime_src = rs: {
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                return pt.undefRef(resolved_type);
-            }
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
 
-            if (maybe_rhs_val) |rhs_val| {
-                if (is_int) {
-                    var overflow_idx: ?usize = null;
-                    const res = try lhs_val.intDiv(rhs_val, resolved_type, &overflow_idx, sema.arena, pt);
-                    if (overflow_idx) |vec_idx| {
-                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
-                    }
-                    return Air.internedToRef(res.toIntern());
-                } else {
-                    return Air.internedToRef((try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                }
-            } else {
-                break :rs rhs_src;
-            }
+    if (maybe_lhs_val) |lhs_val| {
+        if (maybe_rhs_val) |rhs_val| {
+            const result = try arith.div(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src, .div);
+            return Air.internedToRef(result.toIntern());
+        }
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
         } else {
-            break :rs lhs_src;
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
         }
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivIntOverflowSafety(block, src, resolved_type, lhs_scalar_ty, maybe_lhs_val, maybe_rhs_val, casted_lhs, casted_rhs, is_int);
@@ -15525,9 +15464,8 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
@@ -15540,75 +15478,21 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_exact);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // If the lhs is zero, then zero is returned regardless of rhs.
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, compile error because there is a possible
-        // value for which the division would result in a remainder.
-        // TODO: emit runtime safety for if there is a remainder
-        // TODO: emit runtime safety for division by zero
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, compile error because there is a possible
-        // value for which the division would result in a remainder.
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            } else {
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                    const scalar_zero = switch (scalar_tag) {
-                        .comptime_float, .float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .comptime_int, .int => try pt.intValue(resolved_type.scalarType(zcu), 0),
-                        else => unreachable,
-                    };
-                    const zero_val = try sema.splat(resolved_type, scalar_zero);
-                    return Air.internedToRef(zero_val.toIntern());
-                }
-            }
-        }
+    // Because `@divExact` can trigger Illegal Behavior, undefined operands trigger Illegal Behavior.
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
-            // TODO: if the RHS is one, return the LHS directly
+            const result = try arith.div(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src, .div_exact);
+            return Air.internedToRef(result.toIntern());
         }
-        if (maybe_lhs_val) |lhs_val| {
-            if (maybe_rhs_val) |rhs_val| {
-                if (is_int) {
-                    const modulus_val = try lhs_val.intMod(rhs_val, resolved_type, sema.arena, pt);
-                    if (!(modulus_val.compareAllWithZero(.eq, zcu))) {
-                        return sema.fail(block, src, "exact division produced remainder", .{});
-                    }
-                    var overflow_idx: ?usize = null;
-                    const res = try lhs_val.intDiv(rhs_val, resolved_type, &overflow_idx, sema.arena, pt);
-                    if (overflow_idx) |vec_idx| {
-                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
-                    }
-                    return Air.internedToRef(res.toIntern());
-                } else {
-                    const modulus_val = try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, pt);
-                    if (!(modulus_val.compareAllWithZero(.eq, zcu))) {
-                        return sema.fail(block, src, "exact division produced remainder", .{});
-                    }
-                    return Air.internedToRef((try lhs_val.floatDiv(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                }
-            } else break :rs rhs_src;
-        } else break :rs lhs_src;
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+        if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+    }
 
     // Depending on whether safety is enabled, we will have a slightly different strategy
     // here. The `div_exact` AIR instruction causes undefined behavior if a remainder
@@ -15691,91 +15575,45 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
     const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
     const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
 
     const is_int = scalar_tag == .int or scalar_tag == .comptime_int;
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_floor);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // If the lhs is zero, then zero is returned regardless of rhs.
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined:
-        //   * if lhs type is signed:
-        //     * if rhs is comptime-known and not -1, result is undefined
-        //     * if rhs is -1 or runtime-known, compile error because there is a
-        //        possible value (-min_int / -1)  for which division would be
-        //        illegal behavior.
-        //   * if lhs type is unsigned, undef is returned regardless of rhs.
-        // TODO: emit runtime safety for division by zero
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, result is undefined.
-        if (maybe_lhs_val) |lhs_val| {
-            if (!lhs_val.isUndef(zcu)) {
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                    const scalar_zero = switch (scalar_tag) {
-                        .comptime_float, .float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .comptime_int, .int => try pt.intValue(resolved_type.scalarType(zcu), 0),
-                        else => unreachable,
-                    };
-                    const zero_val = try sema.splat(resolved_type, scalar_zero);
-                    return Air.internedToRef(zero_val.toIntern());
-                }
-            }
-        }
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
-            // TODO: if the RHS is one, return the LHS directly
+            const result = try arith.div(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src, .div_floor);
+            return Air.internedToRef(result.toIntern());
         }
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                return pt.undefRef(resolved_type);
-            }
-
-            if (maybe_rhs_val) |rhs_val| {
-                if (is_int) {
-                    return Air.internedToRef((try lhs_val.intDivFloor(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                } else {
-                    return Air.internedToRef((try lhs_val.floatDivFloor(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                }
-            } else break :rs rhs_src;
-        } else break :rs lhs_src;
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivIntOverflowSafety(block, src, resolved_type, lhs_scalar_ty, maybe_lhs_val, maybe_rhs_val, casted_lhs, casted_rhs, is_int);
@@ -15802,95 +15640,45 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
     const lhs_scalar_ty = lhs_ty.scalarType(zcu);
-    const rhs_scalar_ty = rhs_ty.scalarType(zcu);
     const scalar_tag = resolved_type.scalarType(zcu).zigTypeTag(zcu);
 
     const is_int = scalar_tag == .int or scalar_tag == .comptime_int;
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .div_trunc);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // If the lhs is zero, then zero is returned regardless of rhs.
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined:
-        //   * if lhs type is signed:
-        //     * if rhs is comptime-known and not -1, result is undefined
-        //     * if rhs is -1 or runtime-known, compile error because there is a
-        //        possible value (-min_int / -1)  for which division would be
-        //        illegal behavior.
-        //   * if lhs type is unsigned, undef is returned regardless of rhs.
-        // TODO: emit runtime safety for division by zero
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, result is undefined.
-        if (maybe_lhs_val) |lhs_val| {
-            if (!lhs_val.isUndef(zcu)) {
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                    const scalar_zero = switch (scalar_tag) {
-                        .comptime_float, .float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .comptime_int, .int => try pt.intValue(resolved_type.scalarType(zcu), 0),
-                        else => unreachable,
-                    };
-                    const zero_val = try sema.splat(resolved_type, scalar_zero);
-                    return Air.internedToRef(zero_val.toIntern());
-                }
-            }
-        }
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
+            const result = try arith.div(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src, .div_trunc);
+            return Air.internedToRef(result.toIntern());
         }
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                if (lhs_scalar_ty.isSignedInt(zcu) and rhs_scalar_ty.isSignedInt(zcu)) {
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (try sema.compareAll(rhs_val, .neq, try pt.intValue(resolved_type, -1), resolved_type)) {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                return pt.undefRef(resolved_type);
-            }
-
-            if (maybe_rhs_val) |rhs_val| {
-                if (is_int) {
-                    var overflow_idx: ?usize = null;
-                    const res = try lhs_val.intDiv(rhs_val, resolved_type, &overflow_idx, sema.arena, pt);
-                    if (overflow_idx) |vec_idx| {
-                        return sema.failWithIntegerOverflow(block, src, resolved_type, res, vec_idx);
-                    }
-                    return Air.internedToRef(res.toIntern());
-                } else {
-                    return Air.internedToRef((try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                }
-            } else break :rs rhs_src;
-        } else break :rs lhs_src;
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivIntOverflowSafety(block, src, resolved_type, lhs_scalar_ty, maybe_lhs_val, maybe_rhs_val, casted_lhs, casted_rhs, is_int);
@@ -15939,46 +15727,81 @@ fn addDivIntOverflowSafety(
         if (try rhs_val.compareAll(.neq, neg_one, resolved_type, pt)) return;
     }
 
-    var ok: Air.Inst.Ref = .none;
     if (resolved_type.zigTypeTag(zcu) == .vector) {
-        if (maybe_lhs_val == null) {
+        const vec_len = resolved_type.vectorLen(zcu);
+
+        // This is a bool vector whose elements are true if the LHS element does NOT equal `min_int`.
+        const lhs_ok: Air.Inst.Ref = if (maybe_lhs_val) |lhs_val| ok: {
+            // The operand is comptime-known; intern a constant bool vector for the potentially unsafe elements.
+            const min_int_scalar = try min_int.elemValue(pt, 0);
+            const elems_ok = try sema.arena.alloc(InternPool.Index, vec_len);
+            for (elems_ok, 0..) |*elem_ok, elem_idx| {
+                const elem_val = try lhs_val.elemValue(pt, elem_idx);
+                elem_ok.* = if (elem_val.eqlScalarNum(min_int_scalar, zcu)) .bool_false else .bool_true;
+            }
+            break :ok Air.internedToRef(try pt.intern(.{ .aggregate = .{
+                .ty = (try pt.vectorType(.{
+                    .len = vec_len,
+                    .child = .bool_type,
+                })).toIntern(),
+                .storage = .{ .elems = elems_ok },
+            } }));
+        } else ok: {
+            // The operand isn't comptime-known; add a runtime comparison.
             const min_int_ref = Air.internedToRef(min_int.toIntern());
-            ok = try block.addCmpVector(casted_lhs, min_int_ref, .neq);
-        }
-        if (maybe_rhs_val == null) {
+            break :ok try block.addCmpVector(casted_lhs, min_int_ref, .neq);
+        };
+
+        // This is a bool vector whose elements are true if the RHS element does NOT equal -1.
+        const rhs_ok: Air.Inst.Ref = if (maybe_rhs_val) |rhs_val| ok: {
+            // The operand is comptime-known; intern a constant bool vector for the potentially unsafe elements.
+            const elems_ok = try sema.arena.alloc(InternPool.Index, vec_len);
+            for (elems_ok, 0..) |*elem_ok, elem_idx| {
+                const elem_val = try rhs_val.elemValue(pt, elem_idx);
+                elem_ok.* = if (elem_val.eqlScalarNum(neg_one_scalar, zcu)) .bool_false else .bool_true;
+            }
+            break :ok Air.internedToRef(try pt.intern(.{ .aggregate = .{
+                .ty = (try pt.vectorType(.{
+                    .len = vec_len,
+                    .child = .bool_type,
+                })).toIntern(),
+                .storage = .{ .elems = elems_ok },
+            } }));
+        } else ok: {
+            // The operand isn't comptime-known; add a runtime comparison.
             const neg_one_ref = Air.internedToRef(neg_one.toIntern());
-            const rhs_ok = try block.addCmpVector(casted_rhs, neg_one_ref, .neq);
-            if (ok == .none) {
-                ok = rhs_ok;
-            } else {
-                ok = try block.addBinOp(.bool_or, ok, rhs_ok);
-            }
-        }
-        assert(ok != .none);
-        ok = try block.addInst(.{
+            break :ok try block.addCmpVector(casted_rhs, neg_one_ref, .neq);
+        };
+
+        const ok = try block.addInst(.{
             .tag = .reduce,
             .data = .{ .reduce = .{
-                .operand = ok,
+                .operand = try block.addBinOp(.bool_or, lhs_ok, rhs_ok),
                 .operation = .And,
             } },
         });
+        try sema.addSafetyCheck(block, src, ok, .integer_overflow);
     } else {
-        if (maybe_lhs_val == null) {
+        const lhs_ok: Air.Inst.Ref = if (maybe_lhs_val == null) ok: {
             const min_int_ref = Air.internedToRef(min_int.toIntern());
-            ok = try block.addBinOp(.cmp_neq, casted_lhs, min_int_ref);
-        }
-        if (maybe_rhs_val == null) {
+            break :ok try block.addBinOp(.cmp_neq, casted_lhs, min_int_ref);
+        } else .none; // means false
+        const rhs_ok: Air.Inst.Ref = if (maybe_rhs_val == null) ok: {
             const neg_one_ref = Air.internedToRef(neg_one.toIntern());
-            const rhs_ok = try block.addBinOp(.cmp_neq, casted_rhs, neg_one_ref);
-            if (ok == .none) {
-                ok = rhs_ok;
-            } else {
-                ok = try block.addBinOp(.bool_or, ok, rhs_ok);
-            }
-        }
-        assert(ok != .none);
+            break :ok try block.addBinOp(.cmp_neq, casted_rhs, neg_one_ref);
+        } else .none; // means false
+
+        const ok = if (lhs_ok != .none and rhs_ok != .none)
+            try block.addBinOp(.bool_or, lhs_ok, rhs_ok)
+        else if (lhs_ok != .none)
+            lhs_ok
+        else if (rhs_ok != .none)
+            rhs_ok
+        else
+            unreachable;
+
+        try sema.addSafetyCheck(block, src, ok, .integer_overflow);
     }
-    try sema.addSafetyCheck(block, src, ok, .integer_overflow);
 }
 
 fn addDivByZeroSafety(
@@ -16046,13 +15869,10 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
-    const is_vector = resolved_type.zigTypeTag(zcu) == .vector;
-
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
     const casted_rhs = try sema.coerce(block, resolved_type, rhs, rhs_src);
 
@@ -16064,96 +15884,66 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod_rem);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // Either operand being undef is a compile error because there exists
-        // a possible value (TODO what is it?) that would invoke illegal behavior.
-        // TODO: can lhs undef be handled better?
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, result is undefined.
-        //
-        // For either one: if the result would be different between @mod and @rem,
-        // then emit a compile error saying you have to pick one.
-        if (is_int) {
-            if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, lhs_src);
-                }
-                if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                    const scalar_zero = switch (scalar_tag) {
-                        .comptime_float, .float => try pt.floatValue(resolved_type.scalarType(zcu), 0.0),
-                        .comptime_int, .int => try pt.intValue(resolved_type.scalarType(zcu), 0),
-                        else => unreachable,
-                    };
-                    const zero_val = if (is_vector) Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                        .ty = resolved_type.toIntern(),
-                        .storage = .{ .repeated_elem = scalar_zero.toIntern() },
-                    } })) else scalar_zero;
-                    return Air.internedToRef(zero_val.toIntern());
-                }
-            } else if (lhs_scalar_ty.isSignedInt(zcu)) {
-                return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                    return sema.failWithDivideByZero(block, rhs_src);
-                }
-                if (!(try rhs_val.compareAllWithZeroSema(.gte, pt))) {
-                    return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-                }
-                if (maybe_lhs_val) |lhs_val| {
-                    const rem_result = try sema.intRem(resolved_type, lhs_val, rhs_val);
-                    // If this answer could possibly be different by doing `intMod`,
-                    // we must emit a compile error. Otherwise, it's OK.
-                    if (!(try lhs_val.compareAllWithZeroSema(.gte, pt)) and
-                        !(try rem_result.compareAllWithZeroSema(.eq, pt)))
-                    {
-                        return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
-                    }
-                    return Air.internedToRef(rem_result.toIntern());
-                }
-                break :rs lhs_src;
-            } else if (rhs_scalar_ty.isSignedInt(zcu)) {
-                return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-            } else {
-                break :rs rhs_src;
-            }
-        }
-        // float operands
+    const lhs_maybe_negative = a: {
+        if (lhs_scalar_ty.isUnsignedInt(zcu)) break :a false;
+        const lhs_val = maybe_lhs_val orelse break :a true;
+        if (lhs_val.compareAllWithZero(.gte, zcu)) break :a false;
+        break :a true;
+    };
+    const rhs_maybe_negative = a: {
+        if (rhs_scalar_ty.isUnsignedInt(zcu)) break :a false;
+        const rhs_val = maybe_rhs_val orelse break :a true;
+        if (rhs_val.compareAllWithZero(.gte, zcu)) break :a false;
+        break :a true;
+    };
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.gte, pt))) {
-                return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
-            }
-            if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(zcu) or !(try lhs_val.compareAllWithZeroSema(.gte, pt))) {
-                    return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
+            const result = try arith.modRem(sema, block, resolved_type, lhs_val, rhs_val, lhs_src, rhs_src, .rem);
+            if (lhs_maybe_negative or rhs_maybe_negative) {
+                if (!result.compareAllWithZero(.eq, zcu)) {
+                    // Non-zero result means ambiguity between mod and rem
+                    return sema.failWithModRemNegative(block, src: {
+                        if (lhs_maybe_negative) break :src lhs_src;
+                        if (rhs_maybe_negative) break :src rhs_src;
+                        unreachable;
+                    }, lhs_ty, rhs_ty);
                 }
-                return Air.internedToRef((try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-            } else {
-                return sema.failWithModRemNegative(block, lhs_src, lhs_ty, rhs_ty);
             }
-        } else {
-            return sema.failWithModRemNegative(block, rhs_src, lhs_ty, rhs_ty);
+            return Air.internedToRef(result.toIntern());
         }
-    };
+    }
 
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+    // Result not comptime-known, so floats and signed integers are illegal due to mod/rem ambiguity
+    if (lhs_maybe_negative or rhs_maybe_negative) {
+        return sema.failWithModRemNegative(block, src: {
+            if (lhs_maybe_negative) break :src lhs_src;
+            if (rhs_maybe_negative) break :src rhs_src;
+            unreachable;
+        }, lhs_ty, rhs_ty);
+    }
+
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
+
+    if (maybe_lhs_val) |lhs_val| {
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivByZeroSafety(block, src, resolved_type, maybe_rhs_val, casted_rhs, is_int);
@@ -16163,58 +15953,6 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
     return block.addBinOp(air_tag, casted_lhs, casted_rhs);
 }
 
-fn intRem(
-    sema: *Sema,
-    ty: Type,
-    lhs: Value,
-    rhs: Value,
-) CompileError!Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try sema.intRemScalar(lhs_elem, rhs_elem, scalar_ty)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return sema.intRemScalar(lhs, rhs, ty);
-}
-
-fn intRemScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) CompileError!Value {
-    const pt = sema.pt;
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
-    const limbs_q = try sema.arena.alloc(
-        math.big.Limb,
-        lhs_bigint.limbs.len,
-    );
-    const limbs_r = try sema.arena.alloc(
-        math.big.Limb,
-        // TODO: consider reworking Sema to re-use Values rather than
-        // always producing new Value objects.
-        rhs_bigint.limbs.len,
-    );
-    const limbs_buffer = try sema.arena.alloc(
-        math.big.Limb,
-        math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
-    );
-    var result_q = math.big.int.Mutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
-    var result_r = math.big.int.Mutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
-    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer);
-    return pt.intValue_big(scalar_ty, result_r.toConst());
-}
-
 fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref {
     const pt = sema.pt;
     const zcu = pt.zcu;
@@ -16232,9 +15970,8 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
@@ -16246,62 +15983,31 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .mod);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // Either operand being undef is a compile error because there exists
-        // a possible value (TODO what is it?) that would invoke illegal behavior.
-        // TODO: can lhs zero be handled better?
-        // TODO: can lhs undef be handled better?
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, result is undefined.
-        if (is_int) {
-            if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, lhs_src);
-                }
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                    return sema.failWithDivideByZero(block, rhs_src);
-                }
-                if (maybe_lhs_val) |lhs_val| {
-                    return Air.internedToRef((try lhs_val.intMod(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                }
-                break :rs lhs_src;
-            } else {
-                break :rs rhs_src;
-            }
-        }
-        // float operands
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
+            const result = try arith.modRem(sema, block, resolved_type, lhs_val, rhs_val, lhs_src, rhs_src, .mod);
+            return Air.internedToRef(result.toIntern());
         }
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                return pt.undefRef(resolved_type);
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                return Air.internedToRef((try lhs_val.floatMod(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-            } else break :rs rhs_src;
-        } else break :rs lhs_src;
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivByZeroSafety(block, src, resolved_type, maybe_rhs_val, casted_rhs, is_int);
@@ -16328,9 +16034,8 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
     try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src);
     try sema.checkInvalidPtrIntArithmetic(block, src, lhs_ty);
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
@@ -16342,62 +16047,31 @@ fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins
 
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, .rem);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-    const runtime_src = rs: {
-        // For integers:
-        // Either operand being undef is a compile error because there exists
-        // a possible value (TODO what is it?) that would invoke illegal behavior.
-        // TODO: can lhs zero be handled better?
-        // TODO: can lhs undef be handled better?
-        //
-        // For floats:
-        // If the rhs is zero, compile error for division by zero.
-        // If the rhs is undefined, compile error because there is a possible
-        // value (zero) for which the division would be illegal behavior.
-        // If the lhs is undefined, result is undefined.
-        if (is_int) {
-            if (maybe_lhs_val) |lhs_val| {
-                if (lhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, lhs_src);
-                }
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                if (rhs_val.isUndef(zcu)) {
-                    return sema.failWithUseOfUndef(block, rhs_src);
-                }
-                if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                    return sema.failWithDivideByZero(block, rhs_src);
-                }
-                if (maybe_lhs_val) |lhs_val| {
-                    return Air.internedToRef((try sema.intRem(resolved_type, lhs_val, rhs_val)).toIntern());
-                }
-                break :rs lhs_src;
-            } else {
-                break :rs rhs_src;
-            }
-        }
-        // float operands
+    const allow_div_zero = !is_int and
+        resolved_type.toIntern() != .comptime_float_type and
+        block.float_mode == .strict;
+
+    if (maybe_lhs_val) |lhs_val| {
         if (maybe_rhs_val) |rhs_val| {
-            if (rhs_val.isUndef(zcu)) {
-                return sema.failWithUseOfUndef(block, rhs_src);
-            }
-            if (!(try rhs_val.compareAllWithZeroSema(.neq, pt))) {
-                return sema.failWithDivideByZero(block, rhs_src);
-            }
+            const result = try arith.modRem(sema, block, resolved_type, lhs_val, rhs_val, lhs_src, rhs_src, .rem);
+            return Air.internedToRef(result.toIntern());
         }
-        if (maybe_lhs_val) |lhs_val| {
-            if (lhs_val.isUndef(zcu)) {
-                return pt.undefRef(resolved_type);
-            }
-            if (maybe_rhs_val) |rhs_val| {
-                return Air.internedToRef((try lhs_val.floatRem(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-            } else break :rs rhs_src;
-        } else break :rs lhs_src;
-    };
-
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+        if (allow_div_zero) {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+    } else if (maybe_rhs_val) |rhs_val| {
+        if (allow_div_zero) {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        } else {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+            if (rhs_val.anyScalarIsZero(zcu)) return sema.failWithDivideByZero(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety()) {
         try sema.addDivByZeroSafety(block, src, resolved_type, maybe_rhs_val, casted_rhs, is_int);
@@ -16486,7 +16160,7 @@ fn zirOverflowArithmetic(
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 
-                        const result = try sema.intAddWithOverflow(lhs_val, rhs_val, dest_ty);
+                        const result = try arith.addWithOverflow(sema, dest_ty, lhs_val, rhs_val);
                         break :result .{ .overflow_bit = result.overflow_bit, .wrapped = result.wrapped_result };
                     }
                 }
@@ -16504,7 +16178,7 @@ fn zirOverflowArithmetic(
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 
-                        const result = try sema.intSubWithOverflow(lhs_val, rhs_val, dest_ty);
+                        const result = try arith.subWithOverflow(sema, dest_ty, lhs_val, rhs_val);
                         break :result .{ .overflow_bit = result.overflow_bit, .wrapped = result.wrapped_result };
                     }
                 }
@@ -16540,7 +16214,7 @@ fn zirOverflowArithmetic(
                             break :result .{ .overflow_bit = Value.undef, .wrapped = Value.undef };
                         }
 
-                        const result = try lhs_val.intMulWithOverflow(rhs_val, dest_ty, sema.arena, pt);
+                        const result = try arith.mulWithOverflow(sema, dest_ty, lhs_val, rhs_val);
                         break :result .{ .overflow_bit = result.overflow_bit, .wrapped = result.wrapped_result };
                     }
                 }
@@ -16741,9 +16415,8 @@ fn analyzeArithmetic(
         }
     }
 
-    const instructions = &[_]Air.Inst.Ref{ lhs, rhs };
-    const resolved_type = try sema.resolvePeerTypes(block, src, instructions, .{
-        .override = &[_]?LazySrcLoc{ lhs_src, rhs_src },
+    const resolved_type = try sema.resolvePeerTypes(block, src, &.{ lhs, rhs }, .{
+        .override = &.{ lhs_src, rhs_src },
     });
 
     const casted_lhs = try sema.coerce(block, resolved_type, lhs, lhs_src);
@@ -16752,407 +16425,74 @@ fn analyzeArithmetic(
     const scalar_type = resolved_type.scalarType(zcu);
     const scalar_tag = scalar_type.zigTypeTag(zcu);
 
-    const is_int = scalar_tag == .int or scalar_tag == .comptime_int;
-
     try sema.checkArithmeticOp(block, src, scalar_tag, lhs_zig_ty_tag, rhs_zig_ty_tag, zir_tag);
 
-    const maybe_lhs_val = try sema.resolveValueIntable(casted_lhs);
-    const maybe_rhs_val = try sema.resolveValueIntable(casted_rhs);
-    const runtime_src: LazySrcLoc, const air_tag: Air.Inst.Tag, const air_tag_safe: Air.Inst.Tag = rs: {
-        switch (zir_tag) {
-            .add, .add_unsafe => {
-                // For integers:intAddSat
-                // If either of the operands are zero, then the other operand is
-                // returned, even if it is undefined.
-                // If either of the operands are undefined, it's a compile error
-                // because there is a possible value for which the addition would
-                // overflow (max_int), causing illegal behavior.
-                // For floats: either operand being undef makes the result undef.
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
-                        return casted_rhs;
-                    }
-                }
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        if (is_int) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        } else {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                }
-                const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .add_optimized else .add;
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(zcu)) {
-                        if (is_int) {
-                            return sema.failWithUseOfUndef(block, lhs_src);
-                        } else {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (is_int) {
-                            var overflow_idx: ?usize = null;
-                            const sum = try sema.intAdd(lhs_val, rhs_val, resolved_type, &overflow_idx);
-                            if (overflow_idx) |vec_idx| {
-                                return sema.failWithIntegerOverflow(block, src, resolved_type, sum, vec_idx);
-                            }
-                            return Air.internedToRef(sum.toIntern());
-                        } else {
-                            return Air.internedToRef((try Value.floatAdd(lhs_val, rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                        }
-                    } else break :rs .{ rhs_src, air_tag, .add_safe };
-                } else break :rs .{ lhs_src, air_tag, .add_safe };
-            },
-            .addwrap => {
-                // Integers only; floats are checked above.
-                // If either of the operands are zero, the other operand is returned.
-                // If either of the operands are undefined, the result is undefined.
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
-                        return casted_rhs;
-                    }
-                }
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        return Air.internedToRef((try sema.numberAddWrapScalar(lhs_val, rhs_val, resolved_type)).toIntern());
-                    } else break :rs .{ lhs_src, .add_wrap, .add_wrap };
-                } else break :rs .{ rhs_src, .add_wrap, .add_wrap };
-            },
-            .add_sat => {
-                // Integers only; floats are checked above.
-                // If either of the operands are zero, then the other operand is returned.
-                // If either of the operands are undefined, the result is undefined.
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu) and (try lhs_val.compareAllWithZeroSema(.eq, pt))) {
-                        return casted_rhs;
-                    }
-                }
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(zcu)) {
-                            return pt.undefRef(resolved_type);
-                        }
-
-                        const val = if (scalar_tag == .comptime_int)
-                            try sema.intAdd(lhs_val, rhs_val, resolved_type, undefined)
-                        else
-                            try lhs_val.intAddSat(rhs_val, resolved_type, sema.arena, pt);
+    // The rules we'll implement below are as follows:
+    //
+    // * If both operands are comptime-known, we call the corresponding function in `arith` to get
+    //   the comptime-known result. Inputs which would be IB at runtime are compile errors.
+    //
+    // * Otherwise, if one operand is comptime-known `undefined`, we trigger a compile error if this
+    //   operator can ever possibly trigger IB, or otherwise return comptime-known `undefined`.
+    //
+    // * No other comptime operand detemines a comptime result; e.g. `0 * x` isn't always `0` because
+    //   of `undefined`. Therefore, the remaining cases all become runtime operations.
 
-                        return Air.internedToRef(val.toIntern());
-                    } else break :rs .{
-                        lhs_src,
-                        .add_sat,
-                        .add_sat,
-                    };
-                } else break :rs .{
-                    rhs_src,
-                    .add_sat,
-                    .add_sat,
-                };
-            },
-            .sub => {
-                // For integers:
-                // If the rhs is zero, then the other operand is
-                // returned, even if it is undefined.
-                // If either of the operands are undefined, it's a compile error
-                // because there is a possible value for which the subtraction would
-                // overflow, causing illegal behavior.
-                // For floats: either operand being undef makes the result undef.
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        if (is_int) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        } else {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                }
-                const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .sub_optimized else .sub;
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(zcu)) {
-                        if (is_int) {
-                            return sema.failWithUseOfUndef(block, lhs_src);
-                        } else {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        if (is_int) {
-                            var overflow_idx: ?usize = null;
-                            const diff = try sema.intSub(lhs_val, rhs_val, resolved_type, &overflow_idx);
-                            if (overflow_idx) |vec_idx| {
-                                return sema.failWithIntegerOverflow(block, src, resolved_type, diff, vec_idx);
-                            }
-                            return Air.internedToRef(diff.toIntern());
-                        } else {
-                            return Air.internedToRef((try Value.floatSub(lhs_val, rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                        }
-                    } else break :rs .{ rhs_src, air_tag, .sub_safe };
-                } else break :rs .{ lhs_src, air_tag, .sub_safe };
-            },
-            .subwrap => {
-                // Integers only; floats are checked above.
-                // If the RHS is zero, then the LHS is returned, even if it is undefined.
-                // If either of the operands are undefined, the result is undefined.
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                }
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        return Air.internedToRef((try sema.numberSubWrapScalar(lhs_val, rhs_val, resolved_type)).toIntern());
-                    } else break :rs .{ rhs_src, .sub_wrap, .sub_wrap };
-                } else break :rs .{ lhs_src, .sub_wrap, .sub_wrap };
-            },
-            .sub_sat => {
-                // Integers only; floats are checked above.
-                // If the RHS is zero, then the LHS is returned, even if it is undefined.
-                // If either of the operands are undefined, the result is undefined.
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        return casted_lhs;
-                    }
-                }
-                if (maybe_lhs_val) |lhs_val| {
-                    if (lhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (maybe_rhs_val) |rhs_val| {
-                        const val = if (scalar_tag == .comptime_int)
-                            try sema.intSub(lhs_val, rhs_val, resolved_type, undefined)
-                        else
-                            try lhs_val.intSubSat(rhs_val, resolved_type, sema.arena, pt);
-
-                        return Air.internedToRef(val.toIntern());
-                    } else break :rs .{ rhs_src, .sub_sat, .sub_sat };
-                } else break :rs .{ lhs_src, .sub_sat, .sub_sat };
-            },
-            .mul => {
-                // For integers:
-                // If either of the operands are zero, the result is zero.
-                // If either of the operands are one, the result is the other
-                // operand, even if it is undefined.
-                // If either of the operands are undefined, it's a compile error
-                // because there is a possible value for which the addition would
-                // overflow (max_int), causing illegal behavior.
-                //
-                // For floats:
-                // If either of the operands are undefined, the result is undefined.
-                // If either of the operands are inf, and the other operand is zero,
-                // the result is nan.
-                // If either of the operands are nan, the result is nan.
-                const scalar_zero = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 0.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 0),
-                    else => unreachable,
-                };
-                const scalar_one = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 1.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 1),
-                    else => unreachable,
-                };
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu)) {
-                        if (lhs_val.isNan(zcu)) {
-                            return Air.internedToRef(lhs_val.toIntern());
-                        }
-                        if (try lhs_val.compareAllWithZeroSema(.eq, pt)) lz: {
-                            if (maybe_rhs_val) |rhs_val| {
-                                if (rhs_val.isNan(zcu)) {
-                                    return Air.internedToRef(rhs_val.toIntern());
-                                }
-                                if (rhs_val.isInf(zcu)) {
-                                    return Air.internedToRef((try pt.floatValue(resolved_type, std.math.nan(f128))).toIntern());
-                                }
-                            } else if (resolved_type.isAnyFloat()) {
-                                break :lz;
-                            }
-                            const zero_val = try sema.splat(resolved_type, scalar_zero);
-                            return Air.internedToRef(zero_val.toIntern());
-                        }
-                        if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                            return casted_rhs;
-                        }
-                    }
-                }
-                const air_tag: Air.Inst.Tag = if (block.float_mode == .optimized) .mul_optimized else .mul;
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        if (is_int) {
-                            return sema.failWithUseOfUndef(block, rhs_src);
-                        } else {
-                            return pt.undefRef(resolved_type);
-                        }
-                    }
-                    if (rhs_val.isNan(zcu)) {
-                        return Air.internedToRef(rhs_val.toIntern());
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) rz: {
-                        if (maybe_lhs_val) |lhs_val| {
-                            if (lhs_val.isInf(zcu)) {
-                                return Air.internedToRef((try pt.floatValue(resolved_type, std.math.nan(f128))).toIntern());
-                            }
-                        } else if (resolved_type.isAnyFloat()) {
-                            break :rz;
-                        }
-                        const zero_val = try sema.splat(resolved_type, scalar_zero);
-                        return Air.internedToRef(zero_val.toIntern());
-                    }
-                    if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                        return casted_lhs;
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(zcu)) {
-                            if (is_int) {
-                                return sema.failWithUseOfUndef(block, lhs_src);
-                            } else {
-                                return pt.undefRef(resolved_type);
-                            }
-                        }
-                        if (is_int) {
-                            var overflow_idx: ?usize = null;
-                            const product = try lhs_val.intMul(rhs_val, resolved_type, &overflow_idx, sema.arena, pt);
-                            if (overflow_idx) |vec_idx| {
-                                return sema.failWithIntegerOverflow(block, src, resolved_type, product, vec_idx);
-                            }
-                            return Air.internedToRef(product.toIntern());
-                        } else {
-                            return Air.internedToRef((try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                        }
-                    } else break :rs .{ lhs_src, air_tag, .mul_safe };
-                } else break :rs .{ rhs_src, air_tag, .mul_safe };
-            },
-            .mulwrap => {
-                // Integers only; floats are handled above.
-                // If either of the operands are zero, result is zero.
-                // If either of the operands are one, result is the other operand.
-                // If either of the operands are undefined, result is undefined.
-                const scalar_zero = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 0.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 0),
-                    else => unreachable,
-                };
-                const scalar_one = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 1.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 1),
-                    else => unreachable,
-                };
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu)) {
-                        if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                            const zero_val = try sema.splat(resolved_type, scalar_zero);
-                            return Air.internedToRef(zero_val.toIntern());
-                        }
-                        if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                            return casted_rhs;
-                        }
-                    }
-                }
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        const zero_val = try sema.splat(resolved_type, scalar_zero);
-                        return Air.internedToRef(zero_val.toIntern());
-                    }
-                    if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                        return casted_lhs;
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(zcu)) {
-                            return pt.undefRef(resolved_type);
-                        }
-                        return Air.internedToRef((try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, pt)).toIntern());
-                    } else break :rs .{ lhs_src, .mul_wrap, .mul_wrap };
-                } else break :rs .{ rhs_src, .mul_wrap, .mul_wrap };
-            },
-            .mul_sat => {
-                // Integers only; floats are checked above.
-                // If either of the operands are zero, result is zero.
-                // If either of the operands are one, result is the other operand.
-                // If either of the operands are undefined, result is undefined.
-                const scalar_zero = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 0.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 0),
-                    else => unreachable,
-                };
-                const scalar_one = switch (scalar_tag) {
-                    .comptime_float, .float => try pt.floatValue(scalar_type, 1.0),
-                    .comptime_int, .int => try pt.intValue(scalar_type, 1),
-                    else => unreachable,
-                };
-                if (maybe_lhs_val) |lhs_val| {
-                    if (!lhs_val.isUndef(zcu)) {
-                        if (try lhs_val.compareAllWithZeroSema(.eq, pt)) {
-                            const zero_val = try sema.splat(resolved_type, scalar_zero);
-                            return Air.internedToRef(zero_val.toIntern());
-                        }
-                        if (try sema.compareAll(lhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                            return casted_rhs;
-                        }
-                    }
-                }
-                if (maybe_rhs_val) |rhs_val| {
-                    if (rhs_val.isUndef(zcu)) {
-                        return pt.undefRef(resolved_type);
-                    }
-                    if (try rhs_val.compareAllWithZeroSema(.eq, pt)) {
-                        const zero_val = try sema.splat(resolved_type, scalar_zero);
-                        return Air.internedToRef(zero_val.toIntern());
-                    }
-                    if (try sema.compareAll(rhs_val, .eq, try sema.splat(resolved_type, scalar_one), resolved_type)) {
-                        return casted_lhs;
-                    }
-                    if (maybe_lhs_val) |lhs_val| {
-                        if (lhs_val.isUndef(zcu)) {
-                            return pt.undefRef(resolved_type);
-                        }
+    const is_int = switch (scalar_tag) {
+        .int, .comptime_int => true,
+        .float, .comptime_float => false,
+        else => unreachable,
+    };
 
-                        const val = if (scalar_tag == .comptime_int)
-                            try lhs_val.intMul(rhs_val, resolved_type, undefined, sema.arena, pt)
-                        else
-                            try lhs_val.intMulSat(rhs_val, resolved_type, sema.arena, pt);
+    const maybe_lhs_val = try sema.resolveValueResolveLazy(casted_lhs);
+    const maybe_rhs_val = try sema.resolveValueResolveLazy(casted_rhs);
 
-                        return Air.internedToRef(val.toIntern());
-                    } else break :rs .{ lhs_src, .mul_sat, .mul_sat };
-                } else break :rs .{ rhs_src, .mul_sat, .mul_sat };
-            },
-            else => unreachable,
+    if (maybe_lhs_val) |lhs_val| {
+        if (maybe_rhs_val) |rhs_val| {
+            const result_val = switch (zir_tag) {
+                .add, .add_unsafe => try arith.add(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src),
+                .addwrap => try arith.addWrap(sema, resolved_type, lhs_val, rhs_val),
+                .add_sat => try arith.addSat(sema, resolved_type, lhs_val, rhs_val),
+                .sub => try arith.sub(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src),
+                .subwrap => try arith.subWrap(sema, resolved_type, lhs_val, rhs_val),
+                .sub_sat => try arith.subSat(sema, resolved_type, lhs_val, rhs_val),
+                .mul => try arith.mul(sema, block, resolved_type, lhs_val, rhs_val, src, lhs_src, rhs_src),
+                .mulwrap => try arith.mulWrap(sema, resolved_type, lhs_val, rhs_val),
+                .mul_sat => try arith.mulSat(sema, resolved_type, lhs_val, rhs_val),
+                else => unreachable,
+            };
+            return Air.internedToRef(result_val.toIntern());
         }
+    }
+
+    const air_tag: Air.Inst.Tag, const air_tag_safe: Air.Inst.Tag, const allow_undef: bool = switch (zir_tag) {
+        .add, .add_unsafe => .{ if (block.float_mode == .optimized) .add_optimized else .add, .add_safe, !is_int },
+        .addwrap => .{ .add_wrap, .add_wrap, true },
+        .add_sat => .{ .add_sat, .add_sat, true },
+        .sub => .{ if (block.float_mode == .optimized) .sub_optimized else .sub, .sub_safe, !is_int },
+        .subwrap => .{ .sub_wrap, .sub_wrap, true },
+        .sub_sat => .{ .sub_sat, .sub_sat, true },
+        .mul => .{ if (block.float_mode == .optimized) .mul_optimized else .mul, .mul_safe, !is_int },
+        .mulwrap => .{ .mul_wrap, .mul_wrap, true },
+        .mul_sat => .{ .mul_sat, .mul_sat, true },
+        else => unreachable,
     };
 
-    try sema.requireRuntimeBlock(block, src, runtime_src);
+    if (allow_undef) {
+        if (maybe_lhs_val) |lhs_val| {
+            if (lhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        }
+        if (maybe_rhs_val) |rhs_val| {
+            if (rhs_val.isUndefDeep(zcu)) return pt.undefRef(resolved_type);
+        }
+    } else {
+        if (maybe_lhs_val) |lhs_val| {
+            if (lhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, lhs_src);
+        }
+        if (maybe_rhs_val) |rhs_val| {
+            if (rhs_val.anyScalarIsUndef(zcu)) return sema.failWithUseOfUndef(block, rhs_src);
+        }
+    }
 
     if (block.wantSafety() and want_safety and scalar_tag == .int) {
         if (zcu.backendSupportsFeature(.safety_checked_instructions)) {
@@ -24124,7 +23464,7 @@ fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai
         }
     }
 
-    if (try sema.resolveValueIntable(operand)) |val| {
+    if (try sema.resolveValueResolveLazy(operand)) |val| {
         if (val.isUndef(zcu)) return pt.undefRef(dest_ty);
         if (!dest_is_vector) {
             return Air.internedToRef((try pt.getCoerced(
@@ -25087,8 +24427,8 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.
                 .Xor => accum = try accum.bitwiseXor(elem_val, scalar_ty, sema.arena, pt),
                 .Min => accum = accum.numberMin(elem_val, zcu),
                 .Max => accum = accum.numberMax(elem_val, zcu),
-                .Add => accum = try sema.numberAddWrapScalar(accum, elem_val, scalar_ty),
-                .Mul => accum = try accum.numberMulWrap(elem_val, scalar_ty, sema.arena, pt),
+                .Add => accum = try arith.addMaybeWrap(sema, scalar_ty, accum, elem_val),
+                .Mul => accum = try arith.mulMaybeWrap(sema, scalar_ty, accum, elem_val),
             }
         }
         return Air.internedToRef(accum.toIntern());
@@ -25485,14 +24825,14 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
             const new_val = switch (op) {
                 // zig fmt: off
                 .Xchg => operand_val,
-                .Add  => try sema.numberAddWrapScalar(stored_val, operand_val, elem_ty),
-                .Sub  => try sema.numberSubWrapScalar(stored_val, operand_val, elem_ty),
-                .And  => try                   stored_val.bitwiseAnd   (operand_val, elem_ty, sema.arena, pt ),
-                .Nand => try                   stored_val.bitwiseNand  (operand_val, elem_ty, sema.arena, pt ),
-                .Or   => try                   stored_val.bitwiseOr    (operand_val, elem_ty, sema.arena, pt ),
-                .Xor  => try                   stored_val.bitwiseXor   (operand_val, elem_ty, sema.arena, pt ),
-                .Max  =>                       stored_val.numberMax    (operand_val,                      zcu),
-                .Min  =>                       stored_val.numberMin    (operand_val,                      zcu),
+                .Add  => try arith.addMaybeWrap(sema, elem_ty, stored_val, operand_val),
+                .Sub  => try arith.subMaybeWrap(sema, elem_ty, stored_val, operand_val),
+                .And  => try stored_val.bitwiseAnd   (operand_val, elem_ty, sema.arena, pt ),
+                .Nand => try stored_val.bitwiseNand  (operand_val, elem_ty, sema.arena, pt ),
+                .Or   => try stored_val.bitwiseOr    (operand_val, elem_ty, sema.arena, pt ),
+                .Xor  => try stored_val.bitwiseXor   (operand_val, elem_ty, sema.arena, pt ),
+                .Max  =>     stored_val.numberMax    (operand_val,                      zcu),
+                .Min  =>     stored_val.numberMin    (operand_val,                      zcu),
                 // zig fmt: on
             };
             try sema.storePtrVal(block, src, ptr_val, new_val, elem_ty);
@@ -31437,16 +30777,12 @@ fn storePtr2(
     };
     const maybe_operand_val = try sema.resolveValue(operand);
 
-    const runtime_src = if (try sema.resolveDefinedValue(block, ptr_src, ptr)) |ptr_val| rs: {
-        const operand_val = maybe_operand_val orelse {
-            try sema.checkPtrIsNotComptimeMutable(block, ptr_val, ptr_src, operand_src);
-            break :rs operand_src;
-        };
-        if (sema.isComptimeMutablePtr(ptr_val)) {
-            try sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
-            return;
-        } else break :rs ptr_src;
-    } else ptr_src;
+    const runtime_src = rs: {
+        const ptr_val = try sema.resolveDefinedValue(block, ptr_src, ptr) orelse break :rs ptr_src;
+        if (!sema.isComptimeMutablePtr(ptr_val)) break :rs ptr_src;
+        const operand_val = maybe_operand_val orelse return sema.fail(block, ptr_src, "cannot store runtime value in compile time variable", .{});
+        return sema.storePtrVal(block, src, ptr_val, operand_val, elem_ty);
+    };
 
     // We're performing the store at runtime; as such, we need to make sure the pointee type
     // is not comptime-only. We can hit this case with a `@ptrFromInt` pointer.
@@ -36719,13 +36055,19 @@ fn unionFields(
 
                 break :blk val;
             } else blk: {
-                const val = if (last_tag_val) |val|
-                    try sema.intAdd(val, Value.one_comptime_int, int_tag_ty, undefined)
-                else
-                    try pt.intValue(int_tag_ty, 0);
-                last_tag_val = val;
-
-                break :blk val;
+                if (last_tag_val) |last_tag| {
+                    const result = try arith.incrementDefinedInt(sema, int_tag_ty, last_tag);
+                    if (result.overflow) return sema.fail(
+                        &block_scope,
+                        value_src,
+                        "enumeration value '{}' too large for type '{}'",
+                        .{ result.val.fmtValueSema(pt, sema), int_tag_ty.fmt(pt) },
+                    );
+                    last_tag_val = result.val;
+                } else {
+                    last_tag_val = try pt.intValue(int_tag_ty, 0);
+                }
+                break :blk last_tag_val.?;
             };
             const gop = enum_field_vals.getOrPutAssumeCapacity(enum_tag_val.toIntern());
             if (gop.found_existing) {
@@ -37532,260 +36874,6 @@ fn structFieldIndex(
         return sema.failWithBadStructFieldAccess(block, struct_ty, struct_type, field_src, field_name);
 }
 
-/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
-/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).
-fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize) !Value {
-    const pt = sema.pt;
-    var overflow: usize = undefined;
-    return sema.intAddInner(lhs, rhs, ty, &overflow) catch |err| switch (err) {
-        error.Overflow => {
-            const is_vec = ty.isVector(pt.zcu);
-            overflow_idx.* = if (is_vec) overflow else 0;
-            const safe_ty = if (is_vec) try pt.vectorType(.{
-                .len = ty.vectorLen(pt.zcu),
-                .child = .comptime_int_type,
-            }) else Type.comptime_int;
-            return sema.intAddInner(lhs, rhs, safe_ty, undefined) catch |err1| switch (err1) {
-                error.Overflow => unreachable,
-                else => |e| return e,
-            };
-        },
-        else => |e| return e,
-    };
-}
-
-fn intAddInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize) !Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const val = sema.intAddScalar(lhs_elem, rhs_elem, scalar_ty) catch |err| switch (err) {
-                error.Overflow => {
-                    overflow_idx.* = i;
-                    return error.Overflow;
-                },
-                else => |e| return e,
-            };
-            scalar.* = val.toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return sema.intAddScalar(lhs, rhs, ty);
-}
-
-fn intAddScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) !Value {
-    const pt = sema.pt;
-    if (scalar_ty.toIntern() != .comptime_int_type) {
-        const res = try sema.intAddWithOverflowScalar(lhs, rhs, scalar_ty);
-        if (res.overflow_bit.compareAllWithZero(.neq, pt.zcu)) return error.Overflow;
-        return res.wrapped_result;
-    }
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
-    const limbs = try sema.arena.alloc(
-        std.math.big.Limb,
-        @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
-    );
-    var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.add(lhs_bigint, rhs_bigint);
-    return pt.intValue_big(scalar_ty, result_bigint.toConst());
-}
-
-/// Supports both floats and ints; handles undefined.
-fn numberAddWrapScalar(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return pt.undefValue(ty);
-
-    if (ty.zigTypeTag(zcu) == .comptime_int) {
-        return sema.intAdd(lhs, rhs, ty, undefined);
-    }
-
-    if (ty.isAnyFloat()) {
-        return Value.floatAdd(lhs, rhs, ty, sema.arena, pt);
-    }
-
-    const overflow_result = try sema.intAddWithOverflow(lhs, rhs, ty);
-    return overflow_result.wrapped_result;
-}
-
-/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
-/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).
-fn intSub(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize) !Value {
-    const pt = sema.pt;
-    var overflow: usize = undefined;
-    return sema.intSubInner(lhs, rhs, ty, &overflow) catch |err| switch (err) {
-        error.Overflow => {
-            const is_vec = ty.isVector(pt.zcu);
-            overflow_idx.* = if (is_vec) overflow else 0;
-            const safe_ty = if (is_vec) try pt.vectorType(.{
-                .len = ty.vectorLen(pt.zcu),
-                .child = .comptime_int_type,
-            }) else Type.comptime_int;
-            return sema.intSubInner(lhs, rhs, safe_ty, undefined) catch |err1| switch (err1) {
-                error.Overflow => unreachable,
-                else => |e| return e,
-            };
-        },
-        else => |e| return e,
-    };
-}
-
-fn intSubInner(sema: *Sema, lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize) !Value {
-    const pt = sema.pt;
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try sema.arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const val = sema.intSubScalar(lhs_elem, rhs_elem, scalar_ty) catch |err| switch (err) {
-                error.Overflow => {
-                    overflow_idx.* = i;
-                    return error.Overflow;
-                },
-                else => |e| return e,
-            };
-            scalar.* = val.toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return sema.intSubScalar(lhs, rhs, ty);
-}
-
-fn intSubScalar(sema: *Sema, lhs: Value, rhs: Value, scalar_ty: Type) !Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (scalar_ty.toIntern() != .comptime_int_type) {
-        const res = try sema.intSubWithOverflowScalar(lhs, rhs, scalar_ty);
-        if (res.overflow_bit.compareAllWithZero(.neq, zcu)) return error.Overflow;
-        return res.wrapped_result;
-    }
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
-    const limbs = try sema.arena.alloc(
-        std.math.big.Limb,
-        @max(lhs_bigint.limbs.len, rhs_bigint.limbs.len) + 1,
-    );
-    var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.sub(lhs_bigint, rhs_bigint);
-    return pt.intValue_big(scalar_ty, result_bigint.toConst());
-}
-
-/// Supports both floats and ints; handles undefined.
-fn numberSubWrapScalar(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return pt.undefValue(ty);
-
-    if (ty.zigTypeTag(zcu) == .comptime_int) {
-        return sema.intSub(lhs, rhs, ty, undefined);
-    }
-
-    if (ty.isAnyFloat()) {
-        return Value.floatSub(lhs, rhs, ty, sema.arena, pt);
-    }
-
-    const overflow_result = try sema.intSubWithOverflow(lhs, rhs, ty);
-    return overflow_result.wrapped_result;
-}
-
-fn intSubWithOverflow(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value.OverflowArithmeticResult {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const vec_len = ty.vectorLen(zcu);
-        const overflowed_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const result_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(zcu);
-        for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const of_math_result = try sema.intSubWithOverflowScalar(lhs_elem, rhs_elem, scalar_ty);
-            of.* = of_math_result.overflow_bit.toIntern();
-            scalar.* = of_math_result.wrapped_result.toIntern();
-        }
-        return Value.OverflowArithmeticResult{
-            .overflow_bit = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = (try pt.vectorType(.{ .len = vec_len, .child = .u1_type })).toIntern(),
-                .storage = .{ .elems = overflowed_data },
-            } })),
-            .wrapped_result = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = ty.toIntern(),
-                .storage = .{ .elems = result_data },
-            } })),
-        };
-    }
-    return sema.intSubWithOverflowScalar(lhs, rhs, ty);
-}
-
-fn intSubWithOverflowScalar(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value.OverflowArithmeticResult {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const info = ty.intInfo(zcu);
-
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
-        return .{
-            .overflow_bit = try pt.undefValue(Type.u1),
-            .wrapped_result = try pt.undefValue(ty),
-        };
-    }
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
-    const limbs = try sema.arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcTwosCompLimbCount(info.bits),
-    );
-    var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    const overflowed = result_bigint.subWrap(lhs_bigint, rhs_bigint, info.signedness, info.bits);
-    const wrapped_result = try pt.intValue_big(ty, result_bigint.toConst());
-    return Value.OverflowArithmeticResult{
-        .overflow_bit = try pt.intValue(Type.u1, @intFromBool(overflowed)),
-        .wrapped_result = wrapped_result,
-    };
-}
-
 const IntFromFloatMode = enum { exact, truncate };
 
 fn intFromFloat(
@@ -37982,74 +37070,6 @@ fn enumHasInt(sema: *Sema, ty: Type, int: Value) CompileError!bool {
     return enum_type.tagValueIndex(&zcu.intern_pool, int_coerced.toIntern()) != null;
 }
 
-fn intAddWithOverflow(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value.OverflowArithmeticResult {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const vec_len = ty.vectorLen(zcu);
-        const overflowed_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const result_data = try sema.arena.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(zcu);
-        for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const of_math_result = try sema.intAddWithOverflowScalar(lhs_elem, rhs_elem, scalar_ty);
-            of.* = of_math_result.overflow_bit.toIntern();
-            scalar.* = of_math_result.wrapped_result.toIntern();
-        }
-        return Value.OverflowArithmeticResult{
-            .overflow_bit = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = (try pt.vectorType(.{ .len = vec_len, .child = .u1_type })).toIntern(),
-                .storage = .{ .elems = overflowed_data },
-            } })),
-            .wrapped_result = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = ty.toIntern(),
-                .storage = .{ .elems = result_data },
-            } })),
-        };
-    }
-    return sema.intAddWithOverflowScalar(lhs, rhs, ty);
-}
-
-fn intAddWithOverflowScalar(
-    sema: *Sema,
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-) !Value.OverflowArithmeticResult {
-    const pt = sema.pt;
-    const zcu = pt.zcu;
-    const info = ty.intInfo(zcu);
-
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
-        return .{
-            .overflow_bit = try pt.undefValue(Type.u1),
-            .wrapped_result = try pt.undefValue(ty),
-        };
-    }
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = try lhs.toBigIntSema(&lhs_space, pt);
-    const rhs_bigint = try rhs.toBigIntSema(&rhs_space, pt);
-    const limbs = try sema.arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcTwosCompLimbCount(info.bits),
-    );
-    var result_bigint = std.math.big.int.Mutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    const overflowed = result_bigint.addWrap(lhs_bigint, rhs_bigint, info.signedness, info.bits);
-    const result = try pt.intValue_big(ty, result_bigint.toConst());
-    return Value.OverflowArithmeticResult{
-        .overflow_bit = try pt.intValue(Type.u1, @intFromBool(overflowed)),
-        .wrapped_result = result,
-    };
-}
-
 /// Asserts the values are comparable. Both operands have type `ty`.
 /// For vectors, returns true if the comparison is true for ALL elements.
 ///
@@ -38736,12 +37756,13 @@ fn resolveDeclaredEnumInner(
             }
             break :overflow false;
         } else if (any_values) overflow: {
-            var overflow: ?usize = null;
-            last_tag_val = if (last_tag_val) |val|
-                try sema.intAdd(val, try pt.intValue(int_tag_ty, 1), int_tag_ty, &overflow)
-            else
-                try pt.intValue(int_tag_ty, 0);
-            if (overflow != null) break :overflow true;
+            if (last_tag_val) |last_tag| {
+                const result = try arith.incrementDefinedInt(sema, int_tag_ty, last_tag);
+                last_tag_val = result.val;
+                if (result.overflow) break :overflow true;
+            } else {
+                last_tag_val = try pt.intValue(int_tag_ty, 0);
+            }
             if (wip_ty.nextField(ip, field_name, last_tag_val.?.toIntern())) |conflict| {
                 assert(conflict.kind == .value); // AstGen validated names are unique
                 const other_field_src: LazySrcLoc = .{

@@ -895,7 +895,7 @@ pub fn readFromPackedMemory(
 }
 
 /// Asserts that the value is a float or an integer.
-pub fn toFloat(val: Value, comptime T: type, zcu: *Zcu) T {
+pub fn toFloat(val: Value, comptime T: type, zcu: *const Zcu) T {
     return switch (zcu.intern_pool.indexToKey(val.toIntern())) {
         .int => |int| switch (int.storage) {
             .big_int => |big_int| big_int.toFloat(T),
@@ -1415,17 +1415,63 @@ pub fn unionValue(val: Value, zcu: *Zcu) Value {
     };
 }
 
-pub fn isUndef(val: Value, zcu: *Zcu) bool {
+pub fn isUndef(val: Value, zcu: *const Zcu) bool {
     return zcu.intern_pool.isUndef(val.toIntern());
 }
 
 /// TODO: check for cases such as array that is not marked undef but all the element
 /// values are marked undef, or struct that is not marked undef but all fields are marked
 /// undef, etc.
-pub fn isUndefDeep(val: Value, zcu: *Zcu) bool {
+pub fn isUndefDeep(val: Value, zcu: *const Zcu) bool {
     return val.isUndef(zcu);
 }
 
+/// `val` must have a numeric or vector type.
+/// Returns whether `val` is undefined or contains any undefined elements.
+pub fn anyScalarIsUndef(val: Value, zcu: *const Zcu) bool {
+    switch (zcu.intern_pool.indexToKey(val.toIntern())) {
+        .undef => return true,
+        .int, .float => return false,
+        .aggregate => |agg| {
+            assert(Type.fromInterned(agg.ty).zigTypeTag(zcu) == .vector);
+            for (agg.storage.values()) |elem_val| {
+                if (Value.fromInterned(elem_val).isUndef(zcu)) return true;
+            }
+            return false;
+        },
+        else => unreachable,
+    }
+}
+
+/// `val` must have a numeric or vector type.
+/// Returns whether `val` contains any elements equal to zero.
+/// Asserts that `val` is not `undefined`, nor a vector containing any `undefined` elements.
+pub fn anyScalarIsZero(val: Value, zcu: *Zcu) bool {
+    assert(!val.anyScalarIsUndef(zcu));
+
+    switch (zcu.intern_pool.indexToKey(val.toIntern())) {
+        .int, .float => return val.eqlScalarNum(.zero_comptime_int, zcu),
+        .aggregate => |agg| {
+            assert(Type.fromInterned(agg.ty).zigTypeTag(zcu) == .vector);
+            switch (agg.storage) {
+                .bytes => |str| {
+                    const len = Type.fromInterned(agg.ty).vectorLen(zcu);
+                    const slice = str.toSlice(len, &zcu.intern_pool);
+                    return std.mem.indexOfScalar(u8, slice, 0) != null;
+                },
+                .elems => |elems| {
+                    for (elems) |elem| {
+                        if (Value.fromInterned(elem).isUndef(zcu)) return true;
+                    }
+                    return false;
+                },
+                .repeated_elem => |elem| return Value.fromInterned(elem).isUndef(zcu),
+            }
+        },
+        else => unreachable,
+    }
+}
+
 /// Asserts the value is not undefined and not unreachable.
 /// C pointers with an integer value of 0 are also considered null.
 pub fn isNull(val: Value, zcu: *Zcu) bool {
@@ -1572,295 +1618,6 @@ pub const OverflowArithmeticResult = struct {
     wrapped_result: Value,
 };
 
-/// Supports (vectors of) integers only; asserts neither operand is undefined.
-pub fn intAddSat(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try intAddSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intAddSatScalar(lhs, rhs, ty, arena, pt);
-}
-
-/// Supports integers only; asserts neither operand is undefined.
-pub fn intAddSatScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    assert(!lhs.isUndef(zcu));
-    assert(!rhs.isUndef(zcu));
-
-    const info = ty.intInfo(zcu);
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs = try arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcTwosCompLimbCount(info.bits),
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.addSat(lhs_bigint, rhs_bigint, info.signedness, info.bits);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
-/// Supports (vectors of) integers only; asserts neither operand is undefined.
-pub fn intSubSat(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try intSubSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intSubSatScalar(lhs, rhs, ty, arena, pt);
-}
-
-/// Supports integers only; asserts neither operand is undefined.
-pub fn intSubSatScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-
-    assert(!lhs.isUndef(zcu));
-    assert(!rhs.isUndef(zcu));
-
-    const info = ty.intInfo(zcu);
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs = try arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcTwosCompLimbCount(info.bits),
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    result_bigint.subSat(lhs_bigint, rhs_bigint, info.signedness, info.bits);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
-pub fn intMulWithOverflow(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !OverflowArithmeticResult {
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const vec_len = ty.vectorLen(zcu);
-        const overflowed_data = try arena.alloc(InternPool.Index, vec_len);
-        const result_data = try arena.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(zcu);
-        for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const of_math_result = try intMulWithOverflowScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt);
-            of.* = of_math_result.overflow_bit.toIntern();
-            scalar.* = of_math_result.wrapped_result.toIntern();
-        }
-        return OverflowArithmeticResult{
-            .overflow_bit = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = (try pt.vectorType(.{ .len = vec_len, .child = .u1_type })).toIntern(),
-                .storage = .{ .elems = overflowed_data },
-            } })),
-            .wrapped_result = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = ty.toIntern(),
-                .storage = .{ .elems = result_data },
-            } })),
-        };
-    }
-    return intMulWithOverflowScalar(lhs, rhs, ty, arena, pt);
-}
-
-pub fn intMulWithOverflowScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !OverflowArithmeticResult {
-    const zcu = pt.zcu;
-    const info = ty.intInfo(zcu);
-
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) {
-        return .{
-            .overflow_bit = try pt.undefValue(Type.u1),
-            .wrapped_result = try pt.undefValue(ty),
-        };
-    }
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs = try arena.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + rhs_bigint.limbs.len,
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    const limbs_buffer = try arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
-    );
-    result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, arena);
-
-    const overflowed = !result_bigint.toConst().fitsInTwosComp(info.signedness, info.bits);
-    if (overflowed) {
-        result_bigint.truncate(result_bigint.toConst(), info.signedness, info.bits);
-    }
-
-    return OverflowArithmeticResult{
-        .overflow_bit = try pt.intValue(Type.u1, @intFromBool(overflowed)),
-        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
-    };
-}
-
-/// Supports both (vectors of) floats and ints; handles undefined scalars.
-pub fn numberMulWrap(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try numberMulWrapScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return numberMulWrapScalar(lhs, rhs, ty, arena, pt);
-}
-
-/// Supports both floats and ints; handles undefined.
-pub fn numberMulWrapScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return Value.undef;
-
-    if (ty.zigTypeTag(zcu) == .comptime_int) {
-        return intMul(lhs, rhs, ty, undefined, arena, pt);
-    }
-
-    if (ty.isAnyFloat()) {
-        return floatMul(lhs, rhs, ty, arena, pt);
-    }
-
-    const overflow_result = try intMulWithOverflow(lhs, rhs, ty, arena, pt);
-    return overflow_result.wrapped_result;
-}
-
-/// Supports (vectors of) integers only; asserts neither operand is undefined.
-pub fn intMulSat(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try intMulSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intMulSatScalar(lhs, rhs, ty, arena, pt);
-}
-
-/// Supports (vectors of) integers only; asserts neither operand is undefined.
-pub fn intMulSatScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-
-    assert(!lhs.isUndef(zcu));
-    assert(!rhs.isUndef(zcu));
-
-    const info = ty.intInfo(zcu);
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs = try arena.alloc(
-        std.math.big.Limb,
-        @max(
-            // For the saturate
-            std.math.big.int.calcTwosCompLimbCount(info.bits),
-            lhs_bigint.limbs.len + rhs_bigint.limbs.len,
-        ),
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    const limbs_buffer = try arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
-    );
-    result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, arena);
-    result_bigint.saturate(result_bigint.toConst(), info.signedness, info.bits);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
 /// Supports both floats and ints; handles undefined.
 pub fn numberMax(lhs: Value, rhs: Value, zcu: *Zcu) Value {
     if (lhs.isUndef(zcu) or rhs.isUndef(zcu)) return undef;
@@ -2126,143 +1883,6 @@ pub fn bitwiseXorScalar(lhs: Value, rhs: Value, ty: Type, arena: Allocator, pt:
     return pt.intValue_big(ty, result_bigint.toConst());
 }
 
-/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
-/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).
-pub fn intDiv(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    var overflow: usize = undefined;
-    return intDivInner(lhs, rhs, ty, &overflow, allocator, pt) catch |err| switch (err) {
-        error.Overflow => {
-            const is_vec = ty.isVector(pt.zcu);
-            overflow_idx.* = if (is_vec) overflow else 0;
-            const safe_ty = if (is_vec) try pt.vectorType(.{
-                .len = ty.vectorLen(pt.zcu),
-                .child = .comptime_int_type,
-            }) else Type.comptime_int;
-            return intDivInner(lhs, rhs, safe_ty, undefined, allocator, pt) catch |err1| switch (err1) {
-                error.Overflow => unreachable,
-                else => |e| return e,
-            };
-        },
-        else => |e| return e,
-    };
-}
-
-fn intDivInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const val = intDivScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt) catch |err| switch (err) {
-                error.Overflow => {
-                    overflow_idx.* = i;
-                    return error.Overflow;
-                },
-                else => |e| return e,
-            };
-            scalar.* = val.toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intDivScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn intDivScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    const zcu = pt.zcu;
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs_q = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len,
-    );
-    const limbs_r = try allocator.alloc(
-        std.math.big.Limb,
-        rhs_bigint.limbs.len,
-    );
-    const limbs_buffer = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
-    );
-    var result_q = BigIntMutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
-    var result_r = BigIntMutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
-    result_q.divTrunc(&result_r, lhs_bigint, rhs_bigint, limbs_buffer);
-    if (ty.toIntern() != .comptime_int_type) {
-        const info = ty.intInfo(pt.zcu);
-        if (!result_q.toConst().fitsInTwosComp(info.signedness, info.bits)) {
-            return error.Overflow;
-        }
-    }
-    return pt.intValue_big(ty, result_q.toConst());
-}
-
-pub fn intDivFloor(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try intDivFloorScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intDivFloorScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn intDivFloorScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    const zcu = pt.zcu;
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs_q = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len,
-    );
-    const limbs_r = try allocator.alloc(
-        std.math.big.Limb,
-        rhs_bigint.limbs.len,
-    );
-    const limbs_buffer = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcDivLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len),
-    );
-    var result_q = BigIntMutable{ .limbs = limbs_q, .positive = undefined, .len = undefined };
-    var result_r = BigIntMutable{ .limbs = limbs_r, .positive = undefined, .len = undefined };
-    result_q.divFloor(&result_r, lhs_bigint, rhs_bigint, limbs_buffer);
-    return pt.intValue_big(ty, result_q.toConst());
-}
-
-pub fn intMod(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try intModScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intModScalar(lhs, rhs, ty, allocator, pt);
-}
-
 pub fn intModScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
     // TODO is this a performance issue? maybe we should try the operation without
     // resorting to BigInt first.
@@ -2386,80 +2006,6 @@ pub fn floatModScalar(lhs: Value, rhs: Value, float_type: Type, pt: Zcu.PerThrea
     } }));
 }
 
-/// If the value overflowed the type, returns a comptime_int (or vector thereof) instead, setting
-/// overflow_idx to the vector index the overflow was at (or 0 for a scalar).
-pub fn intMul(lhs: Value, rhs: Value, ty: Type, overflow_idx: *?usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    const zcu = pt.zcu;
-    var overflow: usize = undefined;
-    return intMulInner(lhs, rhs, ty, &overflow, allocator, pt) catch |err| switch (err) {
-        error.Overflow => {
-            const is_vec = ty.isVector(zcu);
-            overflow_idx.* = if (is_vec) overflow else 0;
-            const safe_ty = if (is_vec) try pt.vectorType(.{
-                .len = ty.vectorLen(zcu),
-                .child = .comptime_int_type,
-            }) else Type.comptime_int;
-            return intMulInner(lhs, rhs, safe_ty, undefined, allocator, pt) catch |err1| switch (err1) {
-                error.Overflow => unreachable,
-                else => |e| return e,
-            };
-        },
-        else => |e| return e,
-    };
-}
-
-fn intMulInner(lhs: Value, rhs: Value, ty: Type, overflow_idx: *usize, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const val = intMulScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt) catch |err| switch (err) {
-                error.Overflow => {
-                    overflow_idx.* = i;
-                    return error.Overflow;
-                },
-                else => |e| return e,
-            };
-            scalar.* = val.toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return intMulScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn intMulScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    const zcu = pt.zcu;
-    if (ty.toIntern() != .comptime_int_type) {
-        const res = try intMulWithOverflowScalar(lhs, rhs, ty, allocator, pt);
-        if (res.overflow_bit.compareAllWithZero(.neq, zcu)) return error.Overflow;
-        return res.wrapped_result;
-    }
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    var lhs_space: Value.BigIntSpace = undefined;
-    var rhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const rhs_bigint = rhs.toBigInt(&rhs_space, zcu);
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + rhs_bigint.limbs.len,
-    );
-    var result_bigint = BigIntMutable{ .limbs = limbs, .positive = undefined, .len = undefined };
-    const limbs_buffer = try allocator.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcMulLimbsBufferLen(lhs_bigint.limbs.len, rhs_bigint.limbs.len, 1),
-    );
-    defer allocator.free(limbs_buffer);
-    result_bigint.mul(lhs_bigint, rhs_bigint, limbs_buffer, allocator);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
 pub fn intTrunc(val: Value, ty: Type, allocator: Allocator, signedness: std.builtin.Signedness, bits: u16, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
     if (ty.zigTypeTag(zcu) == .vector) {
@@ -2528,561 +2074,249 @@ pub fn intTruncScalar(
     result_bigint.truncate(val_bigint, signedness, bits);
     return pt.intValue_big(ty, result_bigint.toConst());
 }
-
-pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    const zcu = pt.zcu;
-    if (ty.zigTypeTag(zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
-        const scalar_ty = ty.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try shlScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return shlScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    const zcu = pt.zcu;
-    var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
-    );
-    var result_bigint = BigIntMutable{
-        .limbs = limbs,
-        .positive = undefined,
-        .len = undefined,
-    };
-    result_bigint.shiftLeft(lhs_bigint, shift);
-    if (ty.toIntern() != .comptime_int_type) {
-        const int_info = ty.intInfo(zcu);
-        result_bigint.truncate(result_bigint.toConst(), int_info.signedness, int_info.bits);
-    }
-
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
-pub fn shlWithOverflow(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    allocator: Allocator,
-    pt: Zcu.PerThread,
-) !OverflowArithmeticResult {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const vec_len = ty.vectorLen(pt.zcu);
-        const overflowed_data = try allocator.alloc(InternPool.Index, vec_len);
-        const result_data = try allocator.alloc(InternPool.Index, vec_len);
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            const of_math_result = try shlWithOverflowScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt);
-            of.* = of_math_result.overflow_bit.toIntern();
-            scalar.* = of_math_result.wrapped_result.toIntern();
-        }
-        return OverflowArithmeticResult{
-            .overflow_bit = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = (try pt.vectorType(.{ .len = vec_len, .child = .u1_type })).toIntern(),
-                .storage = .{ .elems = overflowed_data },
-            } })),
-            .wrapped_result = Value.fromInterned(try pt.intern(.{ .aggregate = .{
-                .ty = ty.toIntern(),
-                .storage = .{ .elems = result_data },
-            } })),
-        };
-    }
-    return shlWithOverflowScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn shlWithOverflowScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    allocator: Allocator,
-    pt: Zcu.PerThread,
-) !OverflowArithmeticResult {
-    const zcu = pt.zcu;
-    const info = ty.intInfo(zcu);
-    var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
-    );
-    var result_bigint = BigIntMutable{
-        .limbs = limbs,
-        .positive = undefined,
-        .len = undefined,
-    };
-    result_bigint.shiftLeft(lhs_bigint, shift);
-    const overflowed = !result_bigint.toConst().fitsInTwosComp(info.signedness, info.bits);
-    if (overflowed) {
-        result_bigint.truncate(result_bigint.toConst(), info.signedness, info.bits);
-    }
-    return OverflowArithmeticResult{
-        .overflow_bit = try pt.intValue(Type.u1, @intFromBool(overflowed)),
-        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
-    };
-}
-
-pub fn shlSat(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try shlSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return shlSatScalar(lhs, rhs, ty, arena, pt);
-}
-
-pub fn shlSatScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    const zcu = pt.zcu;
-    const info = ty.intInfo(zcu);
-
-    var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
-    const limbs = try arena.alloc(
-        std.math.big.Limb,
-        std.math.big.int.calcTwosCompLimbCount(info.bits) + 1,
-    );
-    var result_bigint = BigIntMutable{
-        .limbs = limbs,
-        .positive = undefined,
-        .len = undefined,
-    };
-    result_bigint.shiftLeftSat(lhs_bigint, shift, info.signedness, info.bits);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
-pub fn shlTrunc(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try shlTruncScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return shlTruncScalar(lhs, rhs, ty, arena, pt);
-}
-
-pub fn shlTruncScalar(
-    lhs: Value,
-    rhs: Value,
-    ty: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const shifted = try lhs.shl(rhs, ty, arena, pt);
-    const int_info = ty.intInfo(pt.zcu);
-    const truncated = try shifted.intTrunc(ty, arena, int_info.signedness, int_info.bits, pt);
-    return truncated;
-}
-
-pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    if (ty.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
-        const scalar_ty = ty.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try shrScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = ty.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return shrScalar(lhs, rhs, ty, allocator, pt);
-}
-
-pub fn shrScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
-    // TODO is this a performance issue? maybe we should try the operation without
-    // resorting to BigInt first.
-    const zcu = pt.zcu;
-    var lhs_space: Value.BigIntSpace = undefined;
-    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
-    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
-
-    const result_limbs = lhs_bigint.limbs.len -| (shift / (@sizeOf(std.math.big.Limb) * 8));
-    if (result_limbs == 0) {
-        // The shift is enough to remove all the bits from the number, which means the
-        // result is 0 or -1 depending on the sign.
-        if (lhs_bigint.positive) {
-            return pt.intValue(ty, 0);
-        } else {
-            return pt.intValue(ty, -1);
-        }
-    }
-
-    const limbs = try allocator.alloc(
-        std.math.big.Limb,
-        result_limbs,
-    );
-    var result_bigint = BigIntMutable{
-        .limbs = limbs,
-        .positive = undefined,
-        .len = undefined,
-    };
-    result_bigint.shiftRight(lhs_bigint, shift);
-    return pt.intValue_big(ty, result_bigint.toConst());
-}
-
-pub fn floatNeg(
-    val: Value,
-    float_type: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    if (float_type.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
-        const scalar_ty = float_type.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const elem_val = try val.elemValue(pt, i);
-            scalar.* = (try floatNegScalar(elem_val, scalar_ty, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return floatNegScalar(val, float_type, pt);
-}
-
-pub fn floatNegScalar(val: Value, float_type: Type, pt: Zcu.PerThread) !Value {
-    const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = -val.toFloat(f16, zcu) },
-        32 => .{ .f32 = -val.toFloat(f32, zcu) },
-        64 => .{ .f64 = -val.toFloat(f64, zcu) },
-        80 => .{ .f80 = -val.toFloat(f80, zcu) },
-        128 => .{ .f128 = -val.toFloat(f128, zcu) },
-        else => unreachable,
-    };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
-}
-
-pub fn floatAdd(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    if (float_type.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
-        const scalar_ty = float_type.scalarType(zcu);
-        for (result_data, 0..) |*scalar, i| {
-            const lhs_elem = try lhs.elemValue(pt, i);
-            const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatAddScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
-        }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
-    }
-    return floatAddScalar(lhs, rhs, float_type, pt);
-}
-
-pub fn floatAddScalar(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = lhs.toFloat(f16, zcu) + rhs.toFloat(f16, zcu) },
-        32 => .{ .f32 = lhs.toFloat(f32, zcu) + rhs.toFloat(f32, zcu) },
-        64 => .{ .f64 = lhs.toFloat(f64, zcu) + rhs.toFloat(f64, zcu) },
-        80 => .{ .f80 = lhs.toFloat(f80, zcu) + rhs.toFloat(f80, zcu) },
-        128 => .{ .f128 = lhs.toFloat(f128, zcu) + rhs.toFloat(f128, zcu) },
-        else => unreachable,
-    };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
-}
-
-pub fn floatSub(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
+
+pub fn shl(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
     const zcu = pt.zcu;
-    if (float_type.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
-        const scalar_ty = float_type.scalarType(zcu);
+    if (ty.zigTypeTag(zcu) == .vector) {
+        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(zcu));
+        const scalar_ty = ty.scalarType(zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatSubScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
+            scalar.* = (try shlScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
         }
         return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
+            .ty = ty.toIntern(),
             .storage = .{ .elems = result_data },
         } }));
     }
-    return floatSubScalar(lhs, rhs, float_type, pt);
+    return shlScalar(lhs, rhs, ty, allocator, pt);
 }
 
-pub fn floatSubScalar(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    pt: Zcu.PerThread,
-) !Value {
+pub fn shlScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
     const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = lhs.toFloat(f16, zcu) - rhs.toFloat(f16, zcu) },
-        32 => .{ .f32 = lhs.toFloat(f32, zcu) - rhs.toFloat(f32, zcu) },
-        64 => .{ .f64 = lhs.toFloat(f64, zcu) - rhs.toFloat(f64, zcu) },
-        80 => .{ .f80 = lhs.toFloat(f80, zcu) - rhs.toFloat(f80, zcu) },
-        128 => .{ .f128 = lhs.toFloat(f128, zcu) - rhs.toFloat(f128, zcu) },
-        else => unreachable,
+    var lhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
+    const limbs = try allocator.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
+    );
+    var result_bigint = BigIntMutable{
+        .limbs = limbs,
+        .positive = undefined,
+        .len = undefined,
     };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
+    result_bigint.shiftLeft(lhs_bigint, shift);
+    if (ty.toIntern() != .comptime_int_type) {
+        const int_info = ty.intInfo(zcu);
+        result_bigint.truncate(result_bigint.toConst(), int_info.signedness, int_info.bits);
+    }
+
+    return pt.intValue_big(ty, result_bigint.toConst());
 }
 
-pub fn floatDiv(
+pub fn shlWithOverflow(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
-    arena: Allocator,
+    ty: Type,
+    allocator: Allocator,
     pt: Zcu.PerThread,
-) !Value {
-    if (float_type.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(pt.zcu));
-        const scalar_ty = float_type.scalarType(pt.zcu);
-        for (result_data, 0..) |*scalar, i| {
+) !OverflowArithmeticResult {
+    if (ty.zigTypeTag(pt.zcu) == .vector) {
+        const vec_len = ty.vectorLen(pt.zcu);
+        const overflowed_data = try allocator.alloc(InternPool.Index, vec_len);
+        const result_data = try allocator.alloc(InternPool.Index, vec_len);
+        const scalar_ty = ty.scalarType(pt.zcu);
+        for (overflowed_data, result_data, 0..) |*of, *scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatDivScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
+            const of_math_result = try shlWithOverflowScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt);
+            of.* = of_math_result.overflow_bit.toIntern();
+            scalar.* = of_math_result.wrapped_result.toIntern();
         }
-        return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
-            .storage = .{ .elems = result_data },
-        } }));
+        return OverflowArithmeticResult{
+            .overflow_bit = Value.fromInterned(try pt.intern(.{ .aggregate = .{
+                .ty = (try pt.vectorType(.{ .len = vec_len, .child = .u1_type })).toIntern(),
+                .storage = .{ .elems = overflowed_data },
+            } })),
+            .wrapped_result = Value.fromInterned(try pt.intern(.{ .aggregate = .{
+                .ty = ty.toIntern(),
+                .storage = .{ .elems = result_data },
+            } })),
+        };
     }
-    return floatDivScalar(lhs, rhs, float_type, pt);
+    return shlWithOverflowScalar(lhs, rhs, ty, allocator, pt);
 }
 
-pub fn floatDivScalar(
+pub fn shlWithOverflowScalar(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
+    ty: Type,
+    allocator: Allocator,
     pt: Zcu.PerThread,
-) !Value {
+) !OverflowArithmeticResult {
     const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = lhs.toFloat(f16, zcu) / rhs.toFloat(f16, zcu) },
-        32 => .{ .f32 = lhs.toFloat(f32, zcu) / rhs.toFloat(f32, zcu) },
-        64 => .{ .f64 = lhs.toFloat(f64, zcu) / rhs.toFloat(f64, zcu) },
-        80 => .{ .f80 = lhs.toFloat(f80, zcu) / rhs.toFloat(f80, zcu) },
-        128 => .{ .f128 = lhs.toFloat(f128, zcu) / rhs.toFloat(f128, zcu) },
-        else => unreachable,
+    const info = ty.intInfo(zcu);
+    var lhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
+    const limbs = try allocator.alloc(
+        std.math.big.Limb,
+        lhs_bigint.limbs.len + (shift / (@sizeOf(std.math.big.Limb) * 8)) + 1,
+    );
+    var result_bigint = BigIntMutable{
+        .limbs = limbs,
+        .positive = undefined,
+        .len = undefined,
+    };
+    result_bigint.shiftLeft(lhs_bigint, shift);
+    const overflowed = !result_bigint.toConst().fitsInTwosComp(info.signedness, info.bits);
+    if (overflowed) {
+        result_bigint.truncate(result_bigint.toConst(), info.signedness, info.bits);
+    }
+    return OverflowArithmeticResult{
+        .overflow_bit = try pt.intValue(Type.u1, @intFromBool(overflowed)),
+        .wrapped_result = try pt.intValue_big(ty, result_bigint.toConst()),
     };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
 }
 
-pub fn floatDivFloor(
+pub fn shlSat(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
+    ty: Type,
     arena: Allocator,
     pt: Zcu.PerThread,
 ) !Value {
-    if (float_type.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(pt.zcu));
-        const scalar_ty = float_type.scalarType(pt.zcu);
+    if (ty.zigTypeTag(pt.zcu) == .vector) {
+        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
+        const scalar_ty = ty.scalarType(pt.zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatDivFloorScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
+            scalar.* = (try shlSatScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
         }
         return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
+            .ty = ty.toIntern(),
             .storage = .{ .elems = result_data },
         } }));
     }
-    return floatDivFloorScalar(lhs, rhs, float_type, pt);
+    return shlSatScalar(lhs, rhs, ty, arena, pt);
 }
 
-pub fn floatDivFloorScalar(
+pub fn shlSatScalar(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
+    ty: Type,
+    arena: Allocator,
     pt: Zcu.PerThread,
 ) !Value {
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
     const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = @divFloor(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
-        32 => .{ .f32 = @divFloor(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
-        64 => .{ .f64 = @divFloor(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
-        80 => .{ .f80 = @divFloor(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
-        128 => .{ .f128 = @divFloor(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
-        else => unreachable,
+    const info = ty.intInfo(zcu);
+
+    var lhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
+    const limbs = try arena.alloc(
+        std.math.big.Limb,
+        std.math.big.int.calcTwosCompLimbCount(info.bits) + 1,
+    );
+    var result_bigint = BigIntMutable{
+        .limbs = limbs,
+        .positive = undefined,
+        .len = undefined,
     };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
+    result_bigint.shiftLeftSat(lhs_bigint, shift, info.signedness, info.bits);
+    return pt.intValue_big(ty, result_bigint.toConst());
 }
 
-pub fn floatDivTrunc(
+pub fn shlTrunc(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
+    ty: Type,
     arena: Allocator,
     pt: Zcu.PerThread,
 ) !Value {
-    if (float_type.zigTypeTag(pt.zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(pt.zcu));
-        const scalar_ty = float_type.scalarType(pt.zcu);
+    if (ty.zigTypeTag(pt.zcu) == .vector) {
+        const result_data = try arena.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
+        const scalar_ty = ty.scalarType(pt.zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatDivTruncScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
+            scalar.* = (try shlTruncScalar(lhs_elem, rhs_elem, scalar_ty, arena, pt)).toIntern();
         }
         return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
+            .ty = ty.toIntern(),
             .storage = .{ .elems = result_data },
         } }));
     }
-    return floatDivTruncScalar(lhs, rhs, float_type, pt);
+    return shlTruncScalar(lhs, rhs, ty, arena, pt);
 }
 
-pub fn floatDivTruncScalar(
+pub fn shlTruncScalar(
     lhs: Value,
     rhs: Value,
-    float_type: Type,
+    ty: Type,
+    arena: Allocator,
     pt: Zcu.PerThread,
 ) !Value {
-    const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = @divTrunc(lhs.toFloat(f16, zcu), rhs.toFloat(f16, zcu)) },
-        32 => .{ .f32 = @divTrunc(lhs.toFloat(f32, zcu), rhs.toFloat(f32, zcu)) },
-        64 => .{ .f64 = @divTrunc(lhs.toFloat(f64, zcu), rhs.toFloat(f64, zcu)) },
-        80 => .{ .f80 = @divTrunc(lhs.toFloat(f80, zcu), rhs.toFloat(f80, zcu)) },
-        128 => .{ .f128 = @divTrunc(lhs.toFloat(f128, zcu), rhs.toFloat(f128, zcu)) },
-        else => unreachable,
-    };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
+    const shifted = try lhs.shl(rhs, ty, arena, pt);
+    const int_info = ty.intInfo(pt.zcu);
+    const truncated = try shifted.intTrunc(ty, arena, int_info.signedness, int_info.bits, pt);
+    return truncated;
 }
 
-pub fn floatMul(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    arena: Allocator,
-    pt: Zcu.PerThread,
-) !Value {
-    const zcu = pt.zcu;
-    if (float_type.zigTypeTag(zcu) == .vector) {
-        const result_data = try arena.alloc(InternPool.Index, float_type.vectorLen(zcu));
-        const scalar_ty = float_type.scalarType(zcu);
+pub fn shr(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
+    if (ty.zigTypeTag(pt.zcu) == .vector) {
+        const result_data = try allocator.alloc(InternPool.Index, ty.vectorLen(pt.zcu));
+        const scalar_ty = ty.scalarType(pt.zcu);
         for (result_data, 0..) |*scalar, i| {
             const lhs_elem = try lhs.elemValue(pt, i);
             const rhs_elem = try rhs.elemValue(pt, i);
-            scalar.* = (try floatMulScalar(lhs_elem, rhs_elem, scalar_ty, pt)).toIntern();
+            scalar.* = (try shrScalar(lhs_elem, rhs_elem, scalar_ty, allocator, pt)).toIntern();
         }
         return Value.fromInterned(try pt.intern(.{ .aggregate = .{
-            .ty = float_type.toIntern(),
+            .ty = ty.toIntern(),
             .storage = .{ .elems = result_data },
         } }));
     }
-    return floatMulScalar(lhs, rhs, float_type, pt);
+    return shrScalar(lhs, rhs, ty, allocator, pt);
 }
 
-pub fn floatMulScalar(
-    lhs: Value,
-    rhs: Value,
-    float_type: Type,
-    pt: Zcu.PerThread,
-) !Value {
+pub fn shrScalar(lhs: Value, rhs: Value, ty: Type, allocator: Allocator, pt: Zcu.PerThread) !Value {
+    // TODO is this a performance issue? maybe we should try the operation without
+    // resorting to BigInt first.
     const zcu = pt.zcu;
-    const target = zcu.getTarget();
-    const storage: InternPool.Key.Float.Storage = switch (float_type.floatBits(target)) {
-        16 => .{ .f16 = lhs.toFloat(f16, zcu) * rhs.toFloat(f16, zcu) },
-        32 => .{ .f32 = lhs.toFloat(f32, zcu) * rhs.toFloat(f32, zcu) },
-        64 => .{ .f64 = lhs.toFloat(f64, zcu) * rhs.toFloat(f64, zcu) },
-        80 => .{ .f80 = lhs.toFloat(f80, zcu) * rhs.toFloat(f80, zcu) },
-        128 => .{ .f128 = lhs.toFloat(f128, zcu) * rhs.toFloat(f128, zcu) },
-        else => unreachable,
+    var lhs_space: Value.BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_space, zcu);
+    const shift: usize = @intCast(rhs.toUnsignedInt(zcu));
+
+    const result_limbs = lhs_bigint.limbs.len -| (shift / (@sizeOf(std.math.big.Limb) * 8));
+    if (result_limbs == 0) {
+        // The shift is enough to remove all the bits from the number, which means the
+        // result is 0 or -1 depending on the sign.
+        if (lhs_bigint.positive) {
+            return pt.intValue(ty, 0);
+        } else {
+            return pt.intValue(ty, -1);
+        }
+    }
+
+    const limbs = try allocator.alloc(
+        std.math.big.Limb,
+        result_limbs,
+    );
+    var result_bigint = BigIntMutable{
+        .limbs = limbs,
+        .positive = undefined,
+        .len = undefined,
     };
-    return Value.fromInterned(try pt.intern(.{ .float = .{
-        .ty = float_type.toIntern(),
-        .storage = storage,
-    } }));
+    result_bigint.shiftRight(lhs_bigint, shift);
+    return pt.intValue_big(ty, result_bigint.toConst());
 }
 
 pub fn sqrt(val: Value, float_type: Type, arena: Allocator, pt: Zcu.PerThread) !Value {
@@ -4805,3 +4039,29 @@ pub fn doPointersOverlap(ptr_val_a: Value, ptr_val_b: Value, elem_count: u64, zc
         return bytes_diff < need_bytes_diff;
     }
 }
+
+/// `lhs` and `rhs` are both scalar numeric values (int or float).
+/// Supports comparisons between heterogeneous types.
+/// If `lhs` or `rhs` is undef, returns `false`.
+pub fn eqlScalarNum(lhs: Value, rhs: Value, zcu: *Zcu) bool {
+    if (lhs.isUndef(zcu)) return false;
+    if (rhs.isUndef(zcu)) return false;
+
+    if (lhs.isFloat(zcu) or rhs.isFloat(zcu)) {
+        const lhs_f128 = lhs.toFloat(f128, zcu);
+        const rhs_f128 = rhs.toFloat(f128, zcu);
+        return lhs_f128 == rhs_f128;
+    }
+
+    if (lhs.getUnsignedInt(zcu)) |lhs_u64| {
+        if (rhs.getUnsignedInt(zcu)) |rhs_u64| {
+            return lhs_u64 == rhs_u64;
+        }
+    }
+
+    var lhs_bigint_space: BigIntSpace = undefined;
+    var rhs_bigint_space: BigIntSpace = undefined;
+    const lhs_bigint = lhs.toBigInt(&lhs_bigint_space, zcu);
+    const rhs_bigint = rhs.toBigInt(&rhs_bigint_space, zcu);
+    return lhs_bigint.eql(rhs_bigint);
+}

@@ -1716,9 +1716,25 @@ pub const SrcLoc = struct {
                 const node = node_off.toAbsolute(src_loc.base_node);
 
                 switch (tree.nodeTag(node)) {
-                    .assign => {
-                        return tree.nodeToSpan(tree.nodeData(node).node_and_node[0]);
-                    },
+                    .assign,
+                    .assign_mul,
+                    .assign_div,
+                    .assign_mod,
+                    .assign_add,
+                    .assign_sub,
+                    .assign_shl,
+                    .assign_shl_sat,
+                    .assign_shr,
+                    .assign_bit_and,
+                    .assign_bit_xor,
+                    .assign_bit_or,
+                    .assign_mul_wrap,
+                    .assign_add_wrap,
+                    .assign_sub_wrap,
+                    .assign_mul_sat,
+                    .assign_add_sat,
+                    .assign_sub_sat,
+                    => return tree.nodeToSpan(tree.nodeData(node).node_and_node[0]),
                     else => return tree.nodeToSpan(node),
                 }
             },
@@ -1727,9 +1743,25 @@ pub const SrcLoc = struct {
                 const node = node_off.toAbsolute(src_loc.base_node);
 
                 switch (tree.nodeTag(node)) {
-                    .assign => {
-                        return tree.nodeToSpan(tree.nodeData(node).node_and_node[1]);
-                    },
+                    .assign,
+                    .assign_mul,
+                    .assign_div,
+                    .assign_mod,
+                    .assign_add,
+                    .assign_sub,
+                    .assign_shl,
+                    .assign_shl_sat,
+                    .assign_shr,
+                    .assign_bit_and,
+                    .assign_bit_xor,
+                    .assign_bit_or,
+                    .assign_mul_wrap,
+                    .assign_add_wrap,
+                    .assign_sub_wrap,
+                    .assign_mul_sat,
+                    .assign_add_sat,
+                    .assign_sub_sat,
+                    => return tree.nodeToSpan(tree.nodeData(node).node_and_node[1]),
                     else => return tree.nodeToSpan(node),
                 }
             },
@@ -2209,9 +2241,9 @@ pub const LazySrcLoc = struct {
         node_offset_field_default: Ast.Node.Offset,
         /// The source location points to the type of an array or struct initializer.
         node_offset_init_ty: Ast.Node.Offset,
-        /// The source location points to the LHS of an assignment.
+        /// The source location points to the LHS of an assignment (or assign-op, e.g. `+=`).
         node_offset_store_ptr: Ast.Node.Offset,
-        /// The source location points to the RHS of an assignment.
+        /// The source location points to the RHS of an assignment (or assign-op, e.g. `+=`).
         node_offset_store_operand: Ast.Node.Offset,
         /// The source location points to the operand of a `return` statement, or
         /// the `return` itself if there is no explicit operand.

@@ -21685,20 +21685,7 @@ test mulUnsafe {
 }
 
 inline fn multiply(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs * rhs) {
-    if (@inComptime() and @typeInfo(Type) == .vector) {
-        // workaround https://github.com/ziglang/zig/issues/22743
-        // TODO: return @select(Scalar(Type), boolAnd(lhs == lhs, rhs == rhs), lhs * rhs, lhs + rhs);
-        // workaround https://github.com/ziglang/zig/issues/22744
-        var res: Type = undefined;
-        for (0..@typeInfo(Type).vector.len) |i| res[i] = lhs[i] * rhs[i];
-        return res;
-    }
-    // workaround https://github.com/ziglang/zig/issues/22745
-    // TODO: return lhs * rhs;
-    var rt_lhs = lhs;
-    var rt_rhs = rhs;
-    _ = .{ &rt_lhs, &rt_rhs };
-    return rt_lhs * rt_rhs;
+    return lhs * rhs;
 }
 test multiply {
     const test_multiply = binary(multiply, .{});
@@ -21715,24 +21702,8 @@ test divide {
     try test_divide.testFloatVectors();
 }
 
-inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) Type {
-    switch (@typeInfo(Scalar(Type))) {
-        else => @compileError(@typeName(Type)),
-        .int => return @divTrunc(lhs, rhs),
-        .float => {
-            if (@inComptime()) {
-                // workaround https://github.com/ziglang/zig/issues/22748
-                return @trunc(lhs / rhs);
-            }
-            // workaround https://github.com/ziglang/zig/issues/22748
-            // workaround https://github.com/ziglang/zig/issues/22749
-            // TODO: return @divTrunc(lhs, rhs);
-            var rt_lhs = lhs;
-            var rt_rhs = rhs;
-            _ = .{ &rt_lhs, &rt_rhs };
-            return @divTrunc(rt_lhs, rt_rhs);
-        },
-    }
+inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@divTrunc(lhs, rhs)) {
+    return @divTrunc(lhs, rhs);
 }
 test divTrunc {
     const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int });
@@ -21742,24 +21713,8 @@ test divTrunc {
     try test_div_trunc.testFloatVectors();
 }
 
-inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) Type {
-    switch (@typeInfo(Scalar(Type))) {
-        else => @compileError(@typeName(Type)),
-        .int => return @divFloor(lhs, rhs),
-        .float => {
-            if (@inComptime()) {
-                // workaround https://github.com/ziglang/zig/issues/22748
-                return @floor(lhs / rhs);
-            }
-            // workaround https://github.com/ziglang/zig/issues/22748
-            // workaround https://github.com/ziglang/zig/issues/22749
-            // TODO: return @divFloor(lhs, rhs);
-            var rt_lhs = lhs;
-            var rt_rhs = rhs;
-            _ = .{ &rt_lhs, &rt_rhs };
-            return @divFloor(rt_lhs, rt_rhs);
-        },
-    }
+inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@divFloor(lhs, rhs)) {
+    return @divFloor(lhs, rhs);
 }
 test divFloor {
     const test_div_floor = binary(divFloor, .{ .compare = .approx_int });
@@ -21767,31 +21722,8 @@ test divFloor {
     try test_div_floor.testFloatVectors();
 }
 
-// workaround https://github.com/ziglang/zig/issues/22748
-// TODO: @TypeOf(@rem(lhs, rhs))
-inline fn rem(comptime Type: type, lhs: Type, rhs: Type) Type {
-    switch (@typeInfo(Scalar(Type))) {
-        else => @compileError(@typeName(Type)),
-        .int => return @rem(lhs, rhs),
-        .float => {
-            if (@inComptime()) {
-                // workaround https://github.com/ziglang/zig/issues/22748
-                switch (@typeInfo(Type)) {
-                    else => return if (rhs != 0) @rem(lhs, rhs) else nan(Type),
-                    .vector => |info| {
-                        var res: Type = undefined;
-                        inline for (0..info.len) |i| res[i] = if (rhs[i] != 0) @rem(lhs[i], rhs[i]) else nan(Scalar(Type));
-                        return res;
-                    },
-                }
-            }
-            // workaround https://github.com/ziglang/zig/issues/22748
-            // TODO: return @rem(lhs, rhs);
-            var rt_rhs = rhs;
-            _ = &rt_rhs;
-            return @rem(lhs, rt_rhs);
-        },
-    }
+inline fn rem(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@rem(lhs, rhs)) {
+    return @rem(lhs, rhs);
 }
 test rem {
     const test_rem = binary(rem, .{});
@@ -21801,25 +21733,16 @@ test rem {
     try test_rem.testFloatVectors();
 }
 
-inline fn mod(comptime Type: type, lhs: Type, rhs: Type) Type {
+inline fn mod(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(@mod(lhs, rhs)) {
+    // workaround llvm backend bugs
     if (@inComptime()) {
         const scalarMod = struct {
             fn scalarMod(scalar_lhs: Scalar(Type), scalar_rhs: Scalar(Type)) Scalar(Type) {
-                // workaround https://github.com/ziglang/zig/issues/22748
-                if (scalar_rhs == 0) return nan(Scalar(Type));
                 const scalar_rem = @rem(scalar_lhs, scalar_rhs);
                 return if (scalar_rem == 0 or math.signbit(scalar_rem) == math.signbit(scalar_rhs)) scalar_rem else scalar_rem + scalar_rhs;
             }
         }.scalarMod;
-        // workaround https://github.com/ziglang/zig/issues/22748
         switch (@typeInfo(Type)) {
-            // workaround llvm backend bugs
-            // TODO: else => return if (rhs != 0) @mod(lhs, rhs) else nan(Type),
-            // TODO: .vector => |info| {
-            // TODO:     var res: Type = undefined;
-            // TODO:     inline for (0..info.len) |i| res[i] = if (rhs[i] != 0) @mod(lhs[i], rhs[i]) else nan(Scalar(Type));
-            // TODO:     return res;
-            // TODO: },
             else => return scalarMod(lhs, rhs),
             .vector => |info| {
                 var res: Type = undefined;
@@ -21828,11 +21751,7 @@ inline fn mod(comptime Type: type, lhs: Type, rhs: Type) Type {
             },
         }
     }
-    // workaround https://github.com/ziglang/zig/issues/22748
-    // TODO: return @mod(lhs, rhs);
-    var rt_rhs = rhs;
-    _ = &rt_rhs;
-    return @mod(lhs, rt_rhs);
+    return @mod(lhs, rhs);
 }
 test mod {
     const test_mod = binary(mod, .{});

@@ -1696,10 +1696,6 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
     }
 }
 
-test "comptime_float zero divided by zero produces zero" {
-    try expect((0.0 / 0.0) == 0.0);
-}
-
 test "comptime float compared with runtime int" {
     const f = 10.0;
     var i: usize = 0;

@@ -1265,12 +1265,6 @@ test "allow signed integer division/remainder when values are comptime-known and
 
     try expect(5 % 3 == 2);
     try expect(-6 % 3 == 0);
-
-    var undef: i32 = undefined;
-    _ = &undef;
-    if (0 % undef != 0) {
-        @compileError("0 as numerator should return comptime zero independent of denominator");
-    }
 }
 
 test "quad hex float literal parsing accurate" {
@@ -1861,3 +1855,134 @@ test "runtime int comparison to inf is comptime-known" {
     comptime S.doTheTest(f64, 123);
     comptime S.doTheTest(f128, 123);
 }
+
+test "float divide by zero" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
+
+    const S = struct {
+        fn doTheTest(comptime F: type, zero: F, one: F) !void {
+            try expect(math.isPositiveInf(@divTrunc(one, zero)));
+            try expect(math.isPositiveInf(@divFloor(one, zero)));
+
+            try expect(math.isNan(@rem(one, zero)));
+            try expect(math.isNan(@mod(one, zero)));
+        }
+    };
+
+    try S.doTheTest(f16, 0, 1);
+    comptime S.doTheTest(f16, 0, 1) catch unreachable;
+
+    try S.doTheTest(f32, 0, 1);
+    comptime S.doTheTest(f32, 0, 1) catch unreachable;
+
+    try S.doTheTest(f64, 0, 1);
+    comptime S.doTheTest(f64, 0, 1) catch unreachable;
+
+    try S.doTheTest(f80, 0, 1);
+    comptime S.doTheTest(f80, 0, 1) catch unreachable;
+
+    try S.doTheTest(f128, 0, 1);
+    comptime S.doTheTest(f128, 0, 1) catch unreachable;
+}
+
+test "partially-runtime integer vector division would be illegal if vector elements were reordered" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    var lhs: @Vector(2, i8) = .{ -128, 5 };
+    const rhs: @Vector(2, i8) = .{ 1, -1 };
+
+    const expected: @Vector(2, i8) = .{ -128, -5 };
+
+    lhs = lhs; // suppress error
+
+    const trunc = @divTrunc(lhs, rhs);
+    try expect(trunc[0] == expected[0]);
+    try expect(trunc[1] == expected[1]);
+
+    const floor = @divFloor(lhs, rhs);
+    try expect(floor[0] == expected[0]);
+    try expect(floor[1] == expected[1]);
+
+    const exact = @divExact(lhs, rhs);
+    try expect(exact[0] == expected[0]);
+    try expect(exact[1] == expected[1]);
+}
+
+test "float vector division of comptime zero by runtime nan is nan" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
+
+    const ct_zero: @Vector(1, f32) = .{0};
+    var rt_nan: @Vector(1, f32) = .{math.nan(f32)};
+
+    rt_nan = rt_nan; // suppress error
+
+    try expect(math.isNan((@divTrunc(ct_zero, rt_nan))[0]));
+    try expect(math.isNan((@divFloor(ct_zero, rt_nan))[0]));
+    try expect(math.isNan((ct_zero / rt_nan)[0]));
+}
+
+test "float vector multiplication of comptime zero by runtime nan is nan" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const ct_zero: @Vector(1, f32) = .{0};
+    var rt_nan: @Vector(1, f32) = .{math.nan(f32)};
+
+    rt_nan = rt_nan; // suppress error
+
+    try expect(math.isNan((ct_zero * rt_nan)[0]));
+    try expect(math.isNan((rt_nan * ct_zero)[0]));
+}
+
+test "comptime float vector division of zero by nan is nan" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const ct_zero: @Vector(1, f32) = .{0};
+    const ct_nan: @Vector(1, f32) = .{math.nan(f32)};
+
+    comptime assert(math.isNan((@divTrunc(ct_zero, ct_nan))[0]));
+    comptime assert(math.isNan((@divFloor(ct_zero, ct_nan))[0]));
+    comptime assert(math.isNan((ct_zero / ct_nan)[0]));
+}
+
+test "comptime float vector multiplication of zero by nan is nan" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
+
+    const ct_zero: @Vector(1, f32) = .{0};
+    const ct_nan: @Vector(1, f32) = .{math.nan(f32)};
+
+    comptime assert(math.isNan((ct_zero * ct_nan)[0]));
+    comptime assert(math.isNan((ct_nan * ct_zero)[0]));
+}

@@ -1316,6 +1316,8 @@ test "zero multiplicand" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
 
     const zeros = @Vector(2, u32){ 0.0, 0.0 };
     var ones = @Vector(2, u32){ 1.0, 1.0 };

@@ -4,7 +4,5 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :3:10: error: use of undefined value here causes undefined behavior
+// :3:5: error: use of undefined value here causes undefined behavior

@@ -1,24 +0,0 @@
-comptime {
-    const undef: i64 = undefined;
-    const not_undef: i64 = 32;
-
-    // If either of the operands are zero, then the other operand is returned.
-    @compileLog(undef + 0);
-    @compileLog(not_undef + 0);
-    @compileLog(0 + undef);
-    @compileLog(0 + not_undef);
-
-    _ = undef + undef;
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :11:17: error: use of undefined value here causes undefined behavior
-//
-// Compile Log Output:
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, 32)

@@ -9,7 +9,5 @@ export fn a() void {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :8:7: error: cannot assign to constant
+// :8:5: error: cannot assign to constant

@@ -72,24 +72,22 @@ export fn entry18() void {
 }
 
 // error
-// backend=stage2
-// target=native
 //
 // :3:5: error: cannot assign to constant
-// :7:7: error: cannot assign to constant
-// :11:7: error: cannot assign to constant
-// :15:7: error: cannot assign to constant
-// :19:7: error: cannot assign to constant
-// :23:7: error: cannot assign to constant
-// :27:7: error: cannot assign to constant
-// :31:7: error: cannot assign to constant
-// :35:7: error: cannot assign to constant
-// :39:7: error: cannot assign to constant
-// :43:7: error: cannot assign to constant
-// :47:7: error: cannot assign to constant
-// :51:7: error: cannot assign to constant
-// :55:7: error: cannot assign to constant
-// :59:7: error: cannot assign to constant
-// :63:7: error: cannot assign to constant
-// :67:7: error: cannot assign to constant
-// :71:7: error: cannot assign to constant
+// :7:5: error: cannot assign to constant
+// :11:5: error: cannot assign to constant
+// :15:5: error: cannot assign to constant
+// :19:5: error: cannot assign to constant
+// :23:5: error: cannot assign to constant
+// :27:5: error: cannot assign to constant
+// :31:5: error: cannot assign to constant
+// :35:5: error: cannot assign to constant
+// :39:5: error: cannot assign to constant
+// :43:5: error: cannot assign to constant
+// :47:5: error: cannot assign to constant
+// :51:5: error: cannot assign to constant
+// :55:5: error: cannot assign to constant
+// :59:5: error: cannot assign to constant
+// :63:5: error: cannot assign to constant
+// :67:5: error: cannot assign to constant
+// :71:5: error: cannot assign to constant

@@ -6,8 +6,6 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :4:15: error: overflow of vector type '@Vector(4, u8)' with value '.{ 6, 8, 256, 12 }'
+// :4:15: error: overflow of integer type 'u8' with value '256'
 // :4:15: note: when computing vector element at index '2'

@@ -4,7 +4,5 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :3:10: error: use of undefined value here causes undefined behavior
+// :3:5: error: use of undefined value here causes undefined behavior

@@ -1,11 +0,0 @@
-comptime {
-    var a: i64 = undefined;
-    _ = a / a;
-    _ = &a;
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :3:13: error: use of undefined value here causes undefined behavior

@@ -4,7 +4,5 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :3:10: error: use of undefined value here causes undefined behavior
+// :3:5: error: use of undefined value here causes undefined behavior

@@ -1,38 +0,0 @@
-comptime {
-    const undef: i64 = undefined;
-    const not_undef: i64 = 32;
-
-    // If either of the operands are zero, the result is zero.
-    @compileLog(undef * 0);
-    @compileLog(not_undef * 0);
-    @compileLog(0 * undef);
-    @compileLog(0 * not_undef);
-
-    // If either of the operands are one, the result is the other
-    // operand, even if it is undefined.
-    @compileLog(undef * 1);
-    @compileLog(not_undef * 1);
-    @compileLog(1 * undef);
-    @compileLog(1 * not_undef);
-
-    // If either of the operands are undefined, it's a compile error
-    // because there is a possible value for which the addition would
-    // overflow (max_int), causing illegal behavior.
-    _ = undef * undef;
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :21:17: error: use of undefined value here causes undefined behavior
-//
-// Compile Log Output:
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, 32)

@@ -1,38 +0,0 @@
-comptime {
-    const undef: i64 = undefined;
-    const not_undef: i64 = 32;
-
-    // If either of the operands are zero, the result is zero.
-    @compileLog(undef *| 0);
-    @compileLog(not_undef *| 0);
-    @compileLog(0 *| undef);
-    @compileLog(0 *| not_undef);
-
-    // If either of the operands are one, result is the other operand.
-    @compileLog(undef *| 1);
-    @compileLog(not_undef *| 1);
-    @compileLog(1 *| undef);
-    @compileLog(1 *| not_undef);
-
-    // If either of the operands are undefined, result is undefined.
-    @compileLog(undef *| 2);
-    @compileLog(2 *| undef);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :6:5: error: found compile log statement
-//
-// Compile Log Output:
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, undefined)

@@ -1,38 +0,0 @@
-comptime {
-    const undef: i64 = undefined;
-    const not_undef: i64 = 32;
-
-    // If either of the operands are zero, the result is zero.
-    @compileLog(undef *% 0);
-    @compileLog(not_undef *% 0);
-    @compileLog(0 *% undef);
-    @compileLog(0 *% not_undef);
-
-    // If either of the operands are one, result is the other operand.
-    @compileLog(undef *% 1);
-    @compileLog(not_undef *% 1);
-    @compileLog(1 *% undef);
-    @compileLog(1 *% not_undef);
-
-    // If either of the operands are undefined, result is undefined.
-    @compileLog(undef *% 2);
-    @compileLog(2 *% undef);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :6:5: error: found compile log statement
-//
-// Compile Log Output:
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, 0)
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, 32)
-// @as(i64, undefined)
-// @as(i64, undefined)

@@ -18,8 +18,6 @@ export fn function_with_return_type_type() void {
 }
 
 // error
-// backend=stage2
-// target=native
 //
 // :3:7: error: unable to evaluate comptime expression
 // :3:5: note: operation is runtime due to this operand

@@ -3,7 +3,5 @@ export fn foo(a: i32, b: i32) i32 {
 }
 
 // error
-// backend=stage2
-// target=native
 //
 // :2:12: error: remainder division with 'i32' and 'i32': signed integers and floats must use @rem or @mod

@@ -6,12 +6,21 @@ const Small = enum(u2) {
     Five,
 };
 
-export fn entry() void {
-    _ = Small.One;
+const SmallUnion = union(enum(u2)) {
+    one = 1,
+    two,
+    three,
+    four,
+};
+
+comptime {
+    _ = Small;
+}
+comptime {
+    _ = SmallUnion;
 }
 
 // error
-// backend=stage2
-// target=native
 //
 // :6:5: error: enumeration value '4' too large for type 'u2'
+// :13:5: error: enumeration value '4' too large for type 'u2'

@@ -4,7 +4,5 @@ comptime {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :3:10: error: use of undefined value here causes undefined behavior
+// :3:5: error: use of undefined value here causes undefined behavior

@@ -1,20 +0,0 @@
-comptime {
-    const undef: i64 = undefined;
-    const not_undef: i64 = 32;
-
-    // If the rhs is zero, then the other operand is returned, even if it is undefined.
-    @compileLog(undef - 0);
-    @compileLog(not_undef - 0);
-
-    _ = undef - undef;
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :9:17: error: use of undefined value here causes undefined behavior
-//
-// Compile Log Output:
-// @as(i64, undefined)
-// @as(i64, 32)

@@ -1,5 +1,5 @@
 const c = @cImport({
-    _ = 1 + foo;
+    if (foo == 0) {}
 });
 extern var foo: i32;
 export fn entry() void {
@@ -7,9 +7,7 @@ export fn entry() void {
 }
 
 // error
-// backend=stage2
-// target=native
 //
-// :2:11: error: unable to evaluate comptime expression
-// :2:13: note: operation is runtime due to this operand
+// :2:13: error: unable to evaluate comptime expression
+// :2:9: note: operation is runtime due to this operand
 // :1:11: note: operand to '@cImport' is evaluated at comptime

@@ -0,0 +1,6885 @@
+//! For arithmetic operations which can trigger Illegal Behavior, this test evaluates those
+//! operations with undefined operands (or partially-undefined vector operands), and ensures that a
+//! compile error is emitted as expected.
+
+comptime {
+    // Total expected errors:
+    // 29*22*6 + 26*22*5 = 6688
+
+    testType(u8);
+    testType(i8);
+    testType(u32);
+    testType(i32);
+    testType(u500);
+    testType(i500);
+
+    testType(f16);
+    testType(f32);
+    testType(f64);
+    testType(f80);
+    testType(f128);
+}
+
+fn testType(comptime Scalar: type) void {
+    testInner(Scalar, undefined, 1);
+    testInner(Scalar, undefined, undefined);
+    testInner(@Vector(2, Scalar), undefined, undefined);
+    testInner(@Vector(2, Scalar), undefined, .{ 1, 2 });
+    testInner(@Vector(2, Scalar), undefined, .{ 1, undefined });
+    testInner(@Vector(2, Scalar), undefined, .{ undefined, 2 });
+    testInner(@Vector(2, Scalar), undefined, .{ undefined, undefined });
+    testInner(@Vector(2, Scalar), .{ 1, undefined }, undefined);
+    testInner(@Vector(2, Scalar), .{ 1, undefined }, .{ 1, 2 });
+    testInner(@Vector(2, Scalar), .{ 1, undefined }, .{ 1, undefined });
+    testInner(@Vector(2, Scalar), .{ 1, undefined }, .{ undefined, 2 });
+    testInner(@Vector(2, Scalar), .{ 1, undefined }, .{ undefined, undefined });
+    testInner(@Vector(2, Scalar), .{ undefined, 2 }, undefined);
+    testInner(@Vector(2, Scalar), .{ undefined, 2 }, .{ 1, 2 });
+    testInner(@Vector(2, Scalar), .{ undefined, 2 }, .{ 1, undefined });
+    testInner(@Vector(2, Scalar), .{ undefined, 2 }, .{ undefined, 2 });
+    testInner(@Vector(2, Scalar), .{ undefined, 2 }, .{ undefined, undefined });
+    testInner(@Vector(2, Scalar), .{ undefined, undefined }, undefined);
+    testInner(@Vector(2, Scalar), .{ undefined, undefined }, .{ 1, 2 });
+    testInner(@Vector(2, Scalar), .{ undefined, undefined }, .{ 1, undefined });
+    testInner(@Vector(2, Scalar), .{ undefined, undefined }, .{ undefined, 2 });
+    testInner(@Vector(2, Scalar), .{ undefined, undefined }, .{ undefined, undefined });
+}
+
+/// At the time of writing, this is expected to trigger:
+/// * 26 errors if `T` is a float (or vector of floats)
+/// * 29 errors if `T` is an int (or vector of ints)
+fn testInner(comptime T: type, comptime u: T, comptime maybe_defined: T) void {
+    const Scalar = switch (@typeInfo(T)) {
+        .float, .int => T,
+        .vector => |v| v.child,
+        else => unreachable,
+    };
+
+    const mode: std.builtin.FloatMode = switch (@typeInfo(Scalar)) {
+        .float => .optimized,
+        .int => .strict, // it shouldn't matter
+        else => unreachable,
+    };
+
+    _ = struct {
+        const a: T = maybe_defined;
+        var b: T = maybe_defined;
+
+        // undef LHS, comptime-known LHS
+        comptime {
+            @setFloatMode(mode);
+            _ = u / a;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divFloor(u, a);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divTrunc(u, a);
+        }
+        comptime {
+            // Don't need to set float mode, because this can be IB anyway
+            _ = @divExact(u, a);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = u % a;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @mod(u, a);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @rem(u, a);
+        }
+
+        // undef LHS, runtime-known LHS
+        comptime {
+            @setFloatMode(mode);
+            _ = u / b;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divFloor(u, b);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divTrunc(u, b);
+        }
+        comptime {
+            // Don't need to set float mode, because this can be IB anyway
+            _ = @divExact(u, b);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @mod(u, b);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @rem(u, b);
+        }
+
+        // undef RHS, comptime-known LHS
+        comptime {
+            @setFloatMode(mode);
+            _ = a / u;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divFloor(a, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divTrunc(a, u);
+        }
+        comptime {
+            // Don't need to set float mode, because this can be IB anyway
+            _ = @divExact(a, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = a % u;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @mod(a, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @rem(a, u);
+        }
+
+        // undef RHS, runtime-known LHS
+        comptime {
+            @setFloatMode(mode);
+            _ = b / u;
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divFloor(b, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @divTrunc(b, u);
+        }
+        comptime {
+            // Don't need to set float mode, because this can be IB anyway
+            _ = @divExact(b, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @mod(b, u);
+        }
+        comptime {
+            @setFloatMode(mode);
+            _ = @rem(b, u);
+        }
+
+        // The following tests should only fail for integer types.
+
+        comptime {
+            _ = u + a;
+        }
+        comptime {
+            _ = u - a;
+        }
+        comptime {
+            _ = u * a;
+        }
+    };
+}
+
+const std = @import("std");
+
+// error
+//
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:17: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :71:21: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:27: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :75:30: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:27: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :79:30: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:27: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :83:30: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:17: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :87:21: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:22: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :91:25: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:22: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :95:25: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :101:17: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :105:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :109:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :113:27: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :117:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :121:22: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:17: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :127:21: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:27: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :131:30: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:27: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :135:30: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:27: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :139:30: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:17: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :143:21: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:22: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :147:25: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:22: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :151:25: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :157:21: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :161:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :165:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :169:30: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :173:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :177:25: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:17: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :183:21: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:17: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :186:21: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:17: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior
+// :189:21: error: use of undefined value here causes undefined behavior

@@ -0,0 +1,2047 @@
+//! For arithmetic operations which cannot trigger Illegal Behavior, this test evaluates those
+//! operations with undefined operands (or partially-undefined vector operands), and then uses
+//! `@compileLog` to validate the results are as expected in terms of comptime-known undefined.
+
+export fn entry() void {
+    testInt(u8);
+    testInt(i8);
+    testInt(u32);
+    testInt(i32);
+    testInt(u500);
+    testInt(i500);
+
+    testFloat(f16);
+    testFloat(f32);
+    testFloat(f64);
+    testFloat(f80);
+    testFloat(f128);
+}
+
+fn testInt(comptime Int: type) void {
+    testIntWithValue(Int, 3); // all comptime-known
+    testIntWithValue(Int, struct {
+        var rt: Int = 0;
+    }.rt); // partially runtime-known
+}
+
+fn testFloat(comptime Float: type) void {
+    testFloatWithValue(Float, 3.0); // all comptime-known
+    testFloatWithValue(Float, struct {
+        var rt: Float = 0.0;
+    }.rt); // partially runtime-known
+}
+
+inline fn testIntWithValue(comptime Int: type, x: Int) void {
+    const V = @Vector(2, Int);
+    const u: Int = undefined;
+
+    // Wrapping addition
+
+    @compileLog(x +% u); // undef
+    @compileLog(u +% x); // undef
+
+    @compileLog(V{ x, u } +% V{ x, x }); // { 6, undef }
+    @compileLog(V{ u, x } +% V{ x, x }); // { undef, 6 }
+    @compileLog(V{ u, u } +% V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } +% V{ x, u }); // { 6, undef }
+    @compileLog(V{ x, u } +% V{ x, u }); // { 6, undef }
+    @compileLog(V{ u, x } +% V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } +% V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } +% V{ u, x }); // { undef, 6 }
+    @compileLog(V{ x, u } +% V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } +% V{ u, x }); // { undef, 6 }
+    @compileLog(V{ u, u } +% V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } +% V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } +% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } +% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } +% V{ u, u }); // { undef, undef }
+
+    // Saturating addition
+
+    @compileLog(x +| u); // undef
+    @compileLog(u +| x); // undef
+
+    @compileLog(V{ x, u } +| V{ x, x }); // { 6, undef }
+    @compileLog(V{ u, x } +| V{ x, x }); // { undef, 6 }
+    @compileLog(V{ u, u } +| V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } +| V{ x, u }); // { 6, undef }
+    @compileLog(V{ x, u } +| V{ x, u }); // { 6, undef }
+    @compileLog(V{ u, x } +| V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } +| V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } +| V{ u, x }); // { undef, 6 }
+    @compileLog(V{ x, u } +| V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } +| V{ u, x }); // { undef, 6 }
+    @compileLog(V{ u, u } +| V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } +| V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } +| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } +| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } +| V{ u, u }); // { undef, undef }
+
+    // Wrapping subtraction
+
+    @compileLog(x -% u); // undef
+    @compileLog(u -% x); // undef
+
+    @compileLog(V{ x, u } -% V{ x, x }); // { 0, undef }
+    @compileLog(V{ u, x } -% V{ x, x }); // { undef, 0 }
+    @compileLog(V{ u, u } -% V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } -% V{ x, u }); // { 0, undef }
+    @compileLog(V{ x, u } -% V{ x, u }); // { 0, undef }
+    @compileLog(V{ u, x } -% V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } -% V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } -% V{ u, x }); // { undef, 0 }
+    @compileLog(V{ x, u } -% V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } -% V{ u, x }); // { undef, 0 }
+    @compileLog(V{ u, u } -% V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } -% V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } -% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } -% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } -% V{ u, u }); // { undef, undef }
+
+    // Saturating subtraction
+
+    @compileLog(x -| u); // undef
+    @compileLog(u -| x); // undef
+
+    @compileLog(V{ x, u } -| V{ x, x }); // { 0, undef }
+    @compileLog(V{ u, x } -| V{ x, x }); // { undef, 0 }
+    @compileLog(V{ u, u } -| V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } -| V{ x, u }); // { 0, undef }
+    @compileLog(V{ x, u } -| V{ x, u }); // { 0, undef }
+    @compileLog(V{ u, x } -| V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } -| V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } -| V{ u, x }); // { undef, 0 }
+    @compileLog(V{ x, u } -| V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } -| V{ u, x }); // { undef, 0 }
+    @compileLog(V{ u, u } -| V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } -| V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } -| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } -| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } -| V{ u, u }); // { undef, undef }
+
+    // Wrapping multiplication
+
+    @compileLog(x *% u); // undef
+    @compileLog(u *% x); // undef
+
+    @compileLog(V{ x, u } *% V{ x, x }); // { 9, undef }
+    @compileLog(V{ u, x } *% V{ x, x }); // { undef, 9 }
+    @compileLog(V{ u, u } *% V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } *% V{ x, u }); // { 9, undef }
+    @compileLog(V{ x, u } *% V{ x, u }); // { 9, undef }
+    @compileLog(V{ u, x } *% V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } *% V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } *% V{ u, x }); // { undef, 9 }
+    @compileLog(V{ x, u } *% V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } *% V{ u, x }); // { undef, 9 }
+    @compileLog(V{ u, u } *% V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } *% V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } *% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } *% V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } *% V{ u, u }); // { undef, undef }
+
+    // Saturating multiplication
+
+    @compileLog(x *| u); // undef
+    @compileLog(u *| x); // undef
+
+    @compileLog(V{ x, u } *| V{ x, x }); // { 9, undef }
+    @compileLog(V{ u, x } *| V{ x, x }); // { undef, 9 }
+    @compileLog(V{ u, u } *| V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } *| V{ x, u }); // { 9, undef }
+    @compileLog(V{ x, u } *| V{ x, u }); // { 9, undef }
+    @compileLog(V{ u, x } *| V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } *| V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } *| V{ u, x }); // { undef, 9 }
+    @compileLog(V{ x, u } *| V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } *| V{ u, x }); // { undef, 9 }
+    @compileLog(V{ u, u } *| V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } *| V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } *| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } *| V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } *| V{ u, u }); // { undef, undef }
+}
+
+inline fn testFloatWithValue(comptime Float: type, x: Float) void {
+    const V = @Vector(2, Float);
+    const u: Float = undefined;
+
+    // Addition
+
+    @compileLog(x + u); // undef
+    @compileLog(u + x); // undef
+
+    @compileLog(V{ x, u } + V{ x, x }); // { 6, undef }
+    @compileLog(V{ u, x } + V{ x, x }); // { undef, 6 }
+    @compileLog(V{ u, u } + V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } + V{ x, u }); // { 6, undef }
+    @compileLog(V{ x, u } + V{ x, u }); // { 6, undef }
+    @compileLog(V{ u, x } + V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } + V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } + V{ u, x }); // { undef, 6 }
+    @compileLog(V{ x, u } + V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } + V{ u, x }); // { undef, 6 }
+    @compileLog(V{ u, u } + V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } + V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } + V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } + V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } + V{ u, u }); // { undef, undef }
+
+    // Subtraction
+
+    @compileLog(x - u); // undef
+    @compileLog(u - x); // undef
+
+    @compileLog(V{ x, u } - V{ x, x }); // { 0, undef }
+    @compileLog(V{ u, x } - V{ x, x }); // { undef, 0 }
+    @compileLog(V{ u, u } - V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } - V{ x, u }); // { 0, undef }
+    @compileLog(V{ x, u } - V{ x, u }); // { 0, undef }
+    @compileLog(V{ u, x } - V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } - V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } - V{ u, x }); // { undef, 0 }
+    @compileLog(V{ x, u } - V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } - V{ u, x }); // { undef, 0 }
+    @compileLog(V{ u, u } - V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } - V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } - V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } - V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } - V{ u, u }); // { undef, undef }
+
+    // Multiplication
+
+    @compileLog(x * u); // undef
+    @compileLog(u * x); // undef
+
+    @compileLog(V{ x, u } * V{ x, x }); // { 9, undef }
+    @compileLog(V{ u, x } * V{ x, x }); // { undef, 9 }
+    @compileLog(V{ u, u } * V{ x, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } * V{ x, u }); // { 9, undef }
+    @compileLog(V{ x, u } * V{ x, u }); // { 9, undef }
+    @compileLog(V{ u, x } * V{ x, u }); // { undef, undef }
+    @compileLog(V{ u, u } * V{ x, u }); // { undef, undef }
+
+    @compileLog(V{ x, x } * V{ u, x }); // { undef, 9 }
+    @compileLog(V{ x, u } * V{ u, x }); // { undef, undef }
+    @compileLog(V{ u, x } * V{ u, x }); // { undef, 9 }
+    @compileLog(V{ u, u } * V{ u, x }); // { undef, undef }
+
+    @compileLog(V{ x, x } * V{ u, u }); // { undef, undef }
+    @compileLog(V{ x, u } * V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, x } * V{ u, u }); // { undef, undef }
+    @compileLog(V{ u, u } * V{ u, u }); // { undef, undef }
+
+    // Negation
+
+    @compileLog(-u); // undef
+    @compileLog(-V{ x, u }); // { -3, undef }
+    @compileLog(-V{ u, x }); // { undef, -3 }
+    @compileLog(-V{ u, u }); // { undef, undef }
+}
+
+// error
+//
+// :40:5: error: found compile log statement
+// :40:5: note: also here (5 times)
+// :189:5: note: also here (5 times)
+//
+// Compile Log Output:
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ 6, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 6 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ 0, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 0 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ 9, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, 9 })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(u8, undefined)
+// @as(u8, undefined)
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), [runtime value])
+// @as(@Vector(2, u8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ 6, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 6 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ 0, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 0 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ 9, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, 9 })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(i8, undefined)
+// @as(i8, undefined)
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), [runtime value])
+// @as(@Vector(2, i8), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ 6, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 6 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ 0, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 0 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ 9, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, 9 })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(u32, undefined)
+// @as(u32, undefined)
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), [runtime value])
+// @as(@Vector(2, u32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ 6, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 6 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ 0, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 0 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ 9, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, 9 })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(i32, undefined)
+// @as(i32, undefined)
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), [runtime value])
+// @as(@Vector(2, i32), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ 6, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 6 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ 0, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 0 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ 9, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, 9 })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(u500, undefined)
+// @as(u500, undefined)
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), [runtime value])
+// @as(@Vector(2, u500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ 6, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 6 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ 0, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 0 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ 9, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, 9 })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(i500, undefined)
+// @as(i500, undefined)
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), [runtime value])
+// @as(@Vector(2, i500), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), .{ 6, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 6 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), .{ 0, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 0 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), .{ 9, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, 9 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(@Vector(2, f16), .{ -3, undefined })
+// @as(@Vector(2, f16), .{ undefined, -3 })
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f16, undefined)
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), [runtime value])
+// @as(@Vector(2, f16), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), .{ 6, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 6 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), .{ 0, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 0 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), .{ 9, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, 9 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(@Vector(2, f32), .{ -3, undefined })
+// @as(@Vector(2, f32), .{ undefined, -3 })
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f32, undefined)
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), [runtime value])
+// @as(@Vector(2, f32), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), .{ 6, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 6 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), .{ 0, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 0 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), .{ 9, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, 9 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(@Vector(2, f64), .{ -3, undefined })
+// @as(@Vector(2, f64), .{ undefined, -3 })
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f64, undefined)
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), [runtime value])
+// @as(@Vector(2, f64), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), .{ 6, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 6 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), .{ 0, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 0 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), .{ 9, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, 9 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(@Vector(2, f80), .{ -3, undefined })
+// @as(@Vector(2, f80), .{ undefined, -3 })
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f80, undefined)
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), [runtime value])
+// @as(@Vector(2, f80), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), .{ 6, undefined })
+// @as(@Vector(2, f128), .{ undefined, 6 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ 6, undefined })
+// @as(@Vector(2, f128), .{ 6, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 6 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 6 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), .{ 0, undefined })
+// @as(@Vector(2, f128), .{ undefined, 0 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ 0, undefined })
+// @as(@Vector(2, f128), .{ 0, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 0 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 0 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), .{ 9, undefined })
+// @as(@Vector(2, f128), .{ undefined, 9 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ 9, undefined })
+// @as(@Vector(2, f128), .{ 9, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 9 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, 9 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(@Vector(2, f128), .{ -3, undefined })
+// @as(@Vector(2, f128), .{ undefined, -3 })
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(f128, undefined)
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), .{ undefined, undefined })
+// @as(f128, undefined)
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), [runtime value])
+// @as(@Vector(2, f128), .{ undefined, undefined })

Commit 2a4e06bcb3

Commit `2a4e06bcb3`