diff --git a/doc/langref/test_basic_slices.zig b/doc/langref/test_basic_slices.zig index bf775e7215b1..132484564122 100644 --- a/doc/langref/test_basic_slices.zig +++ b/doc/langref/test_basic_slices.zig @@ -44,4 +44,4 @@ test "basic slices" { // asserts that the slice has len > 0. } -// test_safety=index out of bounds +// test_safety=index 10 out of bounds of length 4 diff --git a/doc/langref/test_intCast_builtin.zig b/doc/langref/test_intCast_builtin.zig index cfd5b9c09239..6c61da4b22c6 100644 --- a/doc/langref/test_intCast_builtin.zig +++ b/doc/langref/test_intCast_builtin.zig @@ -5,4 +5,4 @@ test "integer cast panic" { _ = b; } -// test_error=cast truncated bits +// test_error=cast to 'u8' from 'u16' truncated bits: 43981 above 'u8' maximum (255) diff --git a/doc/langref/test_setRuntimeSafety_builtin.zig b/doc/langref/test_setRuntimeSafety_builtin.zig index 84502273b5da..2148619a45c6 100644 --- a/doc/langref/test_setRuntimeSafety_builtin.zig +++ b/doc/langref/test_setRuntimeSafety_builtin.zig @@ -20,5 +20,5 @@ test "@setRuntimeSafety" { } } -// test_safety=integer overflow +// test_safety=add overflowed // optimize=ReleaseFast diff --git a/lib/c.zig b/lib/c.zig index 0534013d3bc3..2868c6172892 100644 --- a/lib/c.zig +++ b/lib/c.zig @@ -60,6 +60,17 @@ pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ? else => std.os.abort(), } } +/// TODO: Rename to `panic` when old interface is removed. +pub fn panic2(comptime _: std.builtin.PanicCause, data: anytype) noreturn { + @setCold(true); + if (builtin.is_test) { + std.debug.panic("{any}", .{data}); + } + switch (native_os) { + .freestanding, .other, .amdhsa, .amdpal => while (true) {}, + else => std.os.abort(), + } +} extern fn main(argc: c_int, argv: [*:null]?[*:0]u8) c_int; fn wasm_start() callconv(.C) void { diff --git a/lib/compiler_rt.zig b/lib/compiler_rt.zig index 173e6af85a5e..a10f34b15424 100644 --- a/lib/compiler_rt.zig +++ b/lib/compiler_rt.zig @@ -1,6 +1,6 @@ const builtin = @import("builtin"); -pub const panic = @import("compiler_rt/common.zig").panic; +pub const panic2 = @import("compiler_rt/common.zig").panic2; comptime { // Integer routines diff --git a/lib/compiler_rt/common.zig b/lib/compiler_rt/common.zig index 38088de7a02c..61ffe2190256 100644 --- a/lib/compiler_rt/common.zig +++ b/lib/compiler_rt/common.zig @@ -65,16 +65,10 @@ pub const gnu_f16_abi = switch (builtin.cpu.arch) { pub const want_sparc_abi = builtin.cpu.arch.isSPARC(); -// Avoid dragging in the runtime safety mechanisms into this .o file, -// unless we're trying to test compiler-rt. -pub fn panic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = error_return_trace; - if (builtin.is_test) { - @setCold(true); - std.debug.panic("{s}", .{msg}); - } else { - unreachable; - } +/// TODO: Rename to `panic` when old interface is removed. +pub fn panic2(_: std.builtin.PanicCause, _: anytype) noreturn { + @setRuntimeSafety(false); + unreachable; } /// AArch64 is the only ABI (at the moment) to support f16 arguments without the diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index 3026911d3f97..b0a4523bde70 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -33,32 +33,6 @@ pub const subsystem: ?std.Target.SubSystem = blk: { pub const StackTrace = struct { index: usize, instruction_addresses: []usize, - - pub fn format( - self: StackTrace, - comptime fmt: []const u8, - options: std.fmt.FormatOptions, - writer: anytype, - ) !void { - if (fmt.len != 0) std.fmt.invalidFmtError(fmt, self); - - // TODO: re-evaluate whether to use format() methods at all. - // Until then, avoid an error when using GeneralPurposeAllocator with WebAssembly - // where it tries to call detectTTYConfig here. - if (builtin.os.tag == .freestanding) return; - - _ = options; - var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); - defer arena.deinit(); - const debug_info = std.debug.getSelfDebugInfo() catch |err| { - return writer.print("\nUnable to print stack trace: Unable to open debug info: {s}\n", .{@errorName(err)}); - }; - const tty_config = std.io.tty.detectConfig(std.io.getStdErr()); - try writer.writeAll("\n"); - std.debug.writeStackTrace(self, writer, arena.allocator(), debug_info, tty_config) catch |err| { - try writer.print("Unable to print stack trace: {s}\n", .{@errorName(err)}); - }; - } }; /// This data structure is used by the Zig language code generation and @@ -752,112 +726,7 @@ pub const panic: PanicFn = if (@hasDecl(root, "panic")) else if (@hasDecl(root, "os") and @hasDecl(root.os, "panic")) root.os.panic else - default_panic; - -/// This function is used by the Zig language code generation and -/// therefore must be kept in sync with the compiler implementation. -pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr: ?usize) noreturn { - @setCold(true); - - // For backends that cannot handle the language features depended on by the - // default panic handler, we have a simpler panic handler: - if (builtin.zig_backend == .stage2_wasm or - builtin.zig_backend == .stage2_arm or - builtin.zig_backend == .stage2_aarch64 or - builtin.zig_backend == .stage2_x86 or - (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or - builtin.zig_backend == .stage2_sparc64 or - builtin.zig_backend == .stage2_spirv64) - { - while (true) { - @breakpoint(); - } - } - - if (builtin.zig_backend == .stage2_riscv64) { - asm volatile ("ecall" - : - : [number] "{a7}" (64), - [arg1] "{a0}" (1), - [arg2] "{a1}" (@intFromPtr(msg.ptr)), - [arg3] "{a2}" (msg.len), - : "memory" - ); - std.posix.exit(127); - } - - switch (builtin.os.tag) { - .freestanding => { - while (true) { - @breakpoint(); - } - }, - .wasi => { - std.debug.print("{s}", .{msg}); - std.posix.abort(); - }, - .uefi => { - const uefi = std.os.uefi; - - const ExitData = struct { - pub fn create_exit_data(exit_msg: []const u8, exit_size: *usize) ![*:0]u16 { - // Need boot services for pool allocation - if (uefi.system_table.boot_services == null) { - return error.BootServicesUnavailable; - } - - // ExitData buffer must be allocated using boot_services.allocatePool - var utf16: []u16 = try uefi.raw_pool_allocator.alloc(u16, 256); - errdefer uefi.raw_pool_allocator.free(utf16); - - if (exit_msg.len > 255) { - return error.MessageTooLong; - } - - var fmt: [256]u8 = undefined; - const slice = try std.fmt.bufPrint(&fmt, "\r\nerr: {s}\r\n", .{exit_msg}); - const len = try std.unicode.utf8ToUtf16Le(utf16, slice); - - utf16[len] = 0; - - exit_size.* = 256; - - return @as([*:0]u16, @ptrCast(utf16.ptr)); - } - }; - - var exit_size: usize = 0; - const exit_data = ExitData.create_exit_data(msg, &exit_size) catch null; - - if (exit_data) |data| { - if (uefi.system_table.std_err) |out| { - _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red); - _ = out.outputString(data); - _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white); - } - } - - if (uefi.system_table.boot_services) |bs| { - _ = bs.exit(uefi.handle, .Aborted, exit_size, exit_data); - } - - // Didn't have boot_services, just fallback to whatever. - std.posix.abort(); - }, - .cuda, .amdhsa => std.posix.abort(), - .plan9 => { - var status: [std.os.plan9.ERRMAX]u8 = undefined; - const len = @min(msg.len, status.len - 1); - @memcpy(status[0..len], msg[0..len]); - status[len] = 0; - std.os.plan9.exits(status[0..len :0]); - }, - else => { - const first_trace_addr = ret_addr orelse @returnAddress(); - std.debug.panicImpl(error_return_trace, first_trace_addr, msg); - }, - } -} + std.debug.panicImpl; pub fn checkNonScalarSentinel(expected: anytype, actual: @TypeOf(expected)) void { if (!std.meta.eql(expected, actual)) { @@ -925,10 +794,301 @@ pub noinline fn returnError(st: *StackTrace) void { } pub inline fn addErrRetTraceAddr(st: *StackTrace, addr: usize) void { - if (st.index < st.instruction_addresses.len) + @setRuntimeSafety(false); + if (st.index < st.instruction_addresses.len) { st.instruction_addresses[st.index] = addr; + } + st.index +%= 1; +} + +/// This type is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub const PanicFnGeneric = fn (comptime PanicCause, anytype) noreturn; + +/// This type is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub const PanicFnSimple = fn (anytype) noreturn; + +/// This type is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub const PanicId = @typeInfo(PanicCause).Union.tag_type.?; + +/// This type is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub const PanicCause = union(enum(u8)) { + message, + unwrapped_error, + returned_noreturn, + reached_unreachable, + corrupt_switch, + accessed_out_of_bounds, + accessed_out_of_order, + accessed_out_of_order_extra, + accessed_inactive_field: type, + accessed_null_value, + divided_by_zero, + memcpy_argument_aliasing, + mismatched_memcpy_argument_lengths, + mismatched_for_loop_capture_lengths, + mismatched_sentinel: type, + mismatched_null_sentinel, + shl_overflowed: type, + shr_overflowed: type, + shift_amt_overflowed: type, + div_with_remainder: type, + mul_overflowed: type, + add_overflowed: type, + sub_overflowed: type, + div_overflowed: type, + cast_truncated_data: Cast, + cast_to_enum_from_invalid: type, + cast_to_error_from_invalid: Cast, + cast_to_ptr_from_invalid: usize, + cast_to_int_from_invalid: Cast, + cast_to_unsigned_from_negative: Cast, + + const ErrorStackTrace = struct { + st: ?*StackTrace, + err: anyerror, + }; + const Bounds = struct { + index: usize, + length: usize, + }; + const OrderedBounds = struct { + start: usize, + end: usize, + }; + const OrderedBoundsExtra = struct { + start: usize, + end: usize, + length: usize, + }; + const AddressRanges = struct { + dest_start: usize, + dest_end: usize, + src_start: usize, + src_end: usize, + }; + const ArgumentLengths = struct { + dest_len: usize, + src_len: usize, + }; + const CaptureLengths = struct { + loop_len: usize, + capture_len: usize, + }; +}; + +/// This type is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub const Cast = struct { + to: type, + from: type, +}; + +/// This function is used by the Zig language code generation and +/// therefore must be kept in sync with the compiler implementation. +pub fn PanicData(comptime cause: PanicCause) type { + switch (cause) { + .message => { + return []const u8; + }, + .returned_noreturn, + .reached_unreachable, + .accessed_null_value, + .divided_by_zero, + .corrupt_switch, + => { + return void; + }, + .unwrapped_error => { + return PanicCause.ErrorStackTrace; + }, + .accessed_out_of_bounds => { + return PanicCause.Bounds; + }, + .accessed_out_of_order => { + return PanicCause.OrderedBounds; + }, + .accessed_out_of_order_extra => { + return PanicCause.OrderedBoundsExtra; + }, + .accessed_inactive_field => |tag_type| { + return struct { expected: tag_type, found: tag_type }; + }, + .memcpy_argument_aliasing => { + return PanicCause.AddressRanges; + }, + .mismatched_memcpy_argument_lengths => { + return PanicCause.ArgumentLengths; + }, + .mismatched_for_loop_capture_lengths => { + return PanicCause.CaptureLengths; + }, + .mismatched_null_sentinel => { + return u8; + }, + .mismatched_sentinel => |elem_type| { + return struct { expected: elem_type, actual: elem_type }; + }, + .mul_overflowed, + .add_overflowed, + .sub_overflowed, + .div_overflowed, + .div_with_remainder, + => |val_type| { + return struct { lhs: val_type, rhs: val_type }; + }, + .shl_overflowed, + .shr_overflowed, + => |int_type| { + switch (@typeInfo(int_type)) { + .Vector => |info| { + return struct { value: int_type, shift_amt: @Vector(info.len, u16) }; + }, + else => { + return struct { value: int_type, shift_amt: u16 }; + }, + } + }, + .shift_amt_overflowed => |int_type| { + switch (@typeInfo(int_type)) { + .Vector => |info| { + return @Vector(info.len, u16); + }, + else => { + return u16; + }, + } + }, + .cast_to_ptr_from_invalid => { + return usize; + }, + .cast_to_int_from_invalid => |num_types| { + return num_types.from; + }, + .cast_truncated_data => |num_types| { + return num_types.from; + }, + .cast_to_unsigned_from_negative => |int_types| { + return int_types.from; + }, + .cast_to_error_from_invalid => |error_type| { + return error_type.from; + }, + .cast_to_enum_from_invalid => |enum_type| { + return @typeInfo(enum_type).Enum.tag_type; + }, + } +} + +pub const panic2 = if (@hasDecl(root, "panic2")) root.panic2 else if (builtin.mode == .Debug) + panicImplData +else + panicImpl; + +pub fn panicImpl(id: anytype) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (@TypeOf(id) == PanicId) { + std.debug.panicImpl(switch (id) { + inline else => |cause| @field(std.debug.panic_messages, @tagName(cause)), + }, null, @returnAddress()); + } else { + std.debug.panicImpl(id, null, @returnAddress()); + } +} - st.index += 1; +pub fn panicImplData(comptime cause: PanicCause, data: anytype) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (@TypeOf(data) == void) @call(.auto, std.debug.panicImpl, .{ + @field(std.debug.panic_messages, @tagName(cause)), null, @returnAddress(), + }); + switch (cause) { + .message => { + std.debug.panicImpl(data, null, @returnAddress()); + }, + .unwrapped_error => @call(.auto, std.debug.panicUnwrappedError, .{ + data.st, data.err, @returnAddress(), + }), + .accessed_out_of_bounds => @call(.auto, std.debug.panicAccessedOutOfBounds, .{ + data.index, data.length, @returnAddress(), + }), + .accessed_out_of_order => @call(.auto, std.debug.panicAccessedOutOfOrder, .{ + data.start, data.end, @returnAddress(), + }), + .accessed_out_of_order_extra => @call(.auto, std.debug.panicAccessedOutOfOrderExtra, .{ + data.start, data.end, data.length, @returnAddress(), + }), + .accessed_inactive_field => @call(.auto, std.debug.panicAccessedInactiveField, .{ + @tagName(data.expected), @tagName(data.found), @returnAddress(), + }), + .memcpy_argument_aliasing => @call(.auto, std.debug.panicMemcpyArgumentAliasing, .{ + data.dest_start, data.dest_end, data.src_start, data.src_end, @returnAddress(), + }), + .mismatched_memcpy_argument_lengths => @call(.auto, std.debug.panicMismatchedMemcpyLengths, .{ + data.dest_len, data.src_len, @returnAddress(), + }), + .mismatched_for_loop_capture_lengths => @call(.auto, std.debug.panicMismatchedForLoopCaptureLengths, .{ + data.loop_len, data.capture_len, @returnAddress(), + }), + .mismatched_null_sentinel => @call(.auto, std.debug.panicMismatchedNullSentinel, .{ + data, @returnAddress(), + }), + .cast_to_enum_from_invalid => |enum_type| @call(.auto, std.debug.panicCastToTagFromInvalid, .{ + std.meta.BestNum(@typeInfo(enum_type).Enum.tag_type), @typeName(enum_type), data, @returnAddress(), + }), + .cast_to_error_from_invalid => |error_type| @call(.auto, std.debug.panicCastToErrorFromInvalid, .{ + error_type.from, @typeName(error_type.to), data, @returnAddress(), + }), + .add_overflowed, + .sub_overflowed, + .mul_overflowed, + .div_overflowed, + => |int_type| @call(.auto, std.debug.panicArithOverflow(std.meta.BestInt(int_type)).combined, .{ + cause, @typeName(std.meta.Scalar(int_type)), std.meta.bestExtrema(int_type), data.lhs, data.rhs, @returnAddress(), + }), + .shl_overflowed => |int_type| @call(.auto, std.debug.panicArithOverflow(std.meta.BestInt(int_type)).shl, .{ + @typeName(std.meta.Scalar(int_type)), data.value, data.shift_amt, ~@abs(@as(std.meta.Scalar(int_type), 0)), @returnAddress(), + }), + .shr_overflowed => |int_type| @call(.auto, std.debug.panicArithOverflow(std.meta.BestInt(int_type)).shr, .{ + @typeName(std.meta.Scalar(int_type)), data.value, data.shift_amt, ~@abs(@as(std.meta.Scalar(int_type), 0)), @returnAddress(), + }), + .shift_amt_overflowed => |int_type| @call(.auto, std.debug.panicArithOverflow(std.meta.BestInt(@TypeOf(data))).shiftRhs, .{ + @typeName(std.meta.Scalar(int_type)), @bitSizeOf(int_type), data, @returnAddress(), + }), + .div_with_remainder => |num_type| @call(.auto, std.debug.panicExactDivisionWithRemainder, .{ + std.meta.BestNum(num_type), data.lhs, data.rhs, @returnAddress(), + }), + .mismatched_sentinel => |elem_type| @call(.auto, std.debug.panicMismatchedSentinel, .{ + std.meta.BestNum(elem_type), @typeName(elem_type), + data.expected, data.actual, + @returnAddress(), + }), + .cast_to_ptr_from_invalid => |alignment| @call(.auto, std.debug.panicCastToPointerFromInvalid, .{ + data, alignment, @returnAddress(), + }), + .cast_to_unsigned_from_negative => |int_types| @call(.auto, std.debug.panicCastToUnsignedFromNegative, .{ + std.meta.BestNum(int_types.to), @typeName(int_types.to), + std.meta.BestNum(int_types.from), @typeName(int_types.from), + data, @returnAddress(), + }), + .cast_to_int_from_invalid => |num_types| @call(.auto, std.debug.panicCastToIntFromInvalid, .{ + std.meta.BestNum(num_types.to), @typeName(num_types.to), + std.meta.BestNum(num_types.from), @typeName(num_types.from), + std.meta.bestExtrema(num_types.to), data, + @returnAddress(), + }), + .cast_truncated_data => |num_types| @call(.auto, std.debug.panicCastTruncatedData, .{ + std.meta.BestNum(num_types.to), @typeName(num_types.to), + std.meta.BestNum(num_types.from), @typeName(num_types.from), + std.meta.bestExtrema(num_types.to), data, + @returnAddress(), + }), + else => @compileError(@field(std.debug.panic_messages, @tagName(cause))), + } } const std = @import("std.zig"); diff --git a/lib/std/debug.zig b/lib/std/debug.zig index 980b027f0ac6..f26631a1e0d5 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -431,7 +431,7 @@ pub fn panicExtra( break :blk &buf; }, }; - std.builtin.panic(msg, trace, ret_addr); + panicImpl(msg, trace, ret_addr); } /// Non-zero whenever the program triggered a panic. @@ -445,11 +445,55 @@ var panic_mutex = std.Thread.Mutex{}; /// This is used to catch and handle panics triggered by the panic handler. threadlocal var panic_stage: usize = 0; -// `panicImpl` could be useful in implementing a custom panic handler which -// calls the default handler (on supported platforms) -pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize, msg: []const u8) noreturn { - @setCold(true); - +fn panicImplWasi(msg: []const u8) noreturn { + std.debug.print("{s}", .{msg}); + std.process.abort(); +} +fn panicImplPlan9(msg: []const u8) noreturn { + var status: [std.os.plan9.ERRMAX]u8 = undefined; + const len = @min(msg.len, status.len - 1); + @memcpy(status[0..len], msg[0..len]); + status[len] = 0; + std.os.plan9.exits(status[0..len :0]); +} +fn panicImplUefi(msg: []const u8) noreturn { + const uefi = std.os.uefi; + const ExitData = struct { + pub fn create_exit_data(exit_msg: []const u8, exit_size: *usize) ![*:0]u16 { + // Need boot services for pool allocation + if (uefi.system_table.boot_services == null) { + return error.BootServicesUnavailable; + } + // ExitData buffer must be allocated using boot_services.allocatePool + var utf16: []u16 = try uefi.raw_pool_allocator.alloc(u16, 256); + errdefer uefi.raw_pool_allocator.free(utf16); + if (exit_msg.len > 255) { + return error.MessageTooLong; + } + var fmt: [256]u8 = undefined; + const slice = try std.fmt.bufPrint(&fmt, "\r\nerr: {s}\r\n", .{exit_msg}); + const len = try std.unicode.utf8ToUtf16Le(utf16, slice); + utf16[len] = 0; + exit_size.* = 256; + return @as([*:0]u16, @ptrCast(utf16.ptr)); + } + }; + var exit_size: usize = 0; + const exit_data = ExitData.create_exit_data(msg, &exit_size) catch null; + if (exit_data) |data| { + if (uefi.system_table.std_err) |out| { + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red); + _ = out.outputString(data); + _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white); + } + } + if (uefi.system_table.boot_services) |bs| { + _ = bs.exit(uefi.handle, .Aborted, exit_size, exit_data); + } + // Didn't have boot_services, just fallback to whatever. + std.process.abort(); +} +fn panicImplDefault(msg: []const u8, trace: ?*const std.builtin.StackTrace, first_trace_addr: usize) noreturn { if (enable_segfault_handler) { // If a segfault happens while panicking, we want it to actually segfault, not trigger // the handler. @@ -497,10 +541,44 @@ pub fn panicImpl(trace: ?*const std.builtin.StackTrace, first_trace_addr: ?usize // Panicked while printing "Panicked during a panic." }, }; - posix.abort(); } - +pub fn panicImpl(msg: []const u8, trace: ?*const std.builtin.StackTrace, ret_addr: ?usize) noreturn { + @setCold(true); + // For backends that cannot handle the language features depended on by the + // default panic handler, we have a simpler panic handler: + if (builtin.zig_backend == .stage2_wasm or + builtin.zig_backend == .stage2_arm or + builtin.zig_backend == .stage2_aarch64 or + builtin.zig_backend == .stage2_x86 or + (builtin.zig_backend == .stage2_x86_64 and (builtin.target.ofmt != .elf and builtin.target.ofmt != .macho)) or + builtin.zig_backend == .stage2_sparc64 or + builtin.zig_backend == .stage2_spirv64) + { + while (true) @breakpoint(); + } + if (builtin.zig_backend == .stage2_riscv64) { + asm volatile ("ecall" + : + : [number] "{a7}" (64), + [arg1] "{a0}" (1), + [arg2] "{a1}" (@intFromPtr(msg.ptr)), + [arg3] "{a2}" (msg.len), + : "memory" + ); + std.posix.exit(127); + } + if (builtin.os.tag == .freestanding) { + while (true) @breakpoint(); + } + switch (builtin.os.tag) { + .cuda, .amdhsa => std.process.abort(), + .wasi => return panicImplWasi(msg), + .uefi => return panicImplUefi(msg), + .plan9 => return panicImplPlan9(msg), + else => return panicImplDefault(msg, trace, ret_addr orelse @returnAddress()), + } +} /// Must be called only after adding 1 to `panicking`. There are three callsites. fn waitForOtherThreadToFinishPanicking() void { if (panicking.fetchSub(1, .seq_cst) != 1) { @@ -2871,6 +2949,714 @@ pub inline fn inValgrind() bool { return std.valgrind.runningOnValgrind() > 0; } +pub fn panicUnwrappedError(st: ?*std.builtin.StackTrace, err: anyerror, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; + buf[0..28].* = "attempted to discard error: ".*; + const ptr: [*]u8 = cpyEquTrunc(buf[28..][0..64], @errorName(err)); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], st, ret_addr); +} +pub fn panicAccessedOutOfBounds(index: usize, length: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 6 + 32 + 25 + 32 = 95 + buf[0..6].* = "index ".*; + var ptr: [*]u8 = formatIntDec(buf[6..][0..32], index); + ptr[0..25].* = " out of bounds of length ".*; + ptr = formatIntDec(ptr[25..][0..32], length); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicAccessedOutOfOrder(start: usize, end: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 12 + 32 + 26 + 32 = 102 + buf[0..12].* = "start index ".*; + var ptr: [*]u8 = formatIntDec(buf[12..][0..32], start); + ptr[0..26].* = " is larger than end index ".*; + ptr = formatIntDec(ptr[26..][0..32], end); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicAccessedOutOfOrderExtra(start: usize, end: usize, length: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; + var ptr: [*]u8 = &buf; + if (start > end) { // max_len: 12 + 32 + 26 + 32 = 102 + ptr[0..12].* = "start index ".*; + ptr = formatIntDec(buf[12..][0..32], start); + ptr[0..26].* = " is larger than end index ".*; + ptr = formatIntDec(ptr[26..][0..32], end); + } else { // max_len: 10 + 32 + 23 + 32 = 97 + ptr[0..10].* = "end index ".*; + ptr = formatIntDec(buf[10..][0..32], end); + ptr[0..23].* = " is larger than length ".*; + ptr = formatIntDec(ptr[23..][0..32], length); + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicMemcpyArgumentAliasing(dest_start: usize, dest_end: usize, src_start: usize, src_end: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 32 + 32 + 5 + 32 + 2 + 32 + 7 = 142 + const max: usize = @max(dest_start, src_start); + const min: usize = @min(dest_end, src_end); + buf[0..32].* = "@memcpy arguments alias between ".*; + var ptr: [*]u8 = formatIntHex(buf[32..][0..32], max); + ptr[0..5].* = " and ".*; + ptr = formatIntHex(ptr[5..][0..32], min); + ptr[0..2].* = " (".*; + ptr = formatIntDec(ptr[2..][0..32], min -% max); + ptr[0..7].* = " bytes)".*; + panicImpl(buf[0 .. @intFromPtr(ptr + 7) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicMismatchedMemcpyLengths(dest_len: usize, src_len: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 68 + 9 + 32 = 109 + buf[0..68].* = "@memcpy destination and source with mismatched lengths: destination ".*; + var ptr: [*]u8 = formatIntDec(buf[68..][0..32], dest_len); + ptr[0..9].* = ", source ".*; + ptr = formatIntDec(ptr[9..][0..32], src_len); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicMismatchedForLoopCaptureLengths(loop_len: usize, capture_len: usize, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 56 + 32 + 12 + 32 = 132 + buf[0..56].* = "multi-for loop captures with mismatched lengths: common ".*; + var ptr: [*]u8 = formatIntDec(buf[56..][0..32], loop_len); + ptr[0..12].* = ", exception ".*; + ptr = formatIntDec(ptr[12..][0..32], capture_len); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicMismatchedNullSentinel(value: u8, ret_addr: usize) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [128]u8 = undefined; // max_len: 28 + 32 = 60 + buf[0..28].* = "mismatched null terminator: ".*; + const ptr: [*]u8 = formatIntDec(buf[28..][0..32], @as(usize, value)); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastToPointerFromInvalid( + address: usize, + alignment: usize, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 42 + 32 + 3 + 32 + 4 + 32 + 1 + 32 = 178 (true branch) + var ptr: [*]u8 = &buf; + if (address != 0) { + ptr[0..42].* = "cast to pointer with incorrect alignment (".*; + ptr = formatIntDec(ptr[42..][0..32], alignment); + ptr[0..3].* = "): ".*; + ptr = formatIntDec(ptr[3..][0..32], address); + ptr[0..4].* = " == ".*; + ptr = formatIntDec(ptr[4..][0..32], address & ~(alignment -% 1)); + ptr[0] = '+'; + ptr = formatIntDec(ptr[1..][0..32], address & (alignment -% 1)); + } else { + ptr[0..40].* = "cast to null pointer without 'allowzero'".*; + ptr += 40; + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastToTagFromInvalid( + comptime Integer: type, + type_name: []const u8, + value: Integer, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [256]u8 = undefined; // max_len: 9 + 64 + 21 + 32 = 126 + buf[0..9].* = "cast to '".*; + var ptr: [*]u8 = cpyEquTrunc(buf[9..][0..64], type_name); + ptr[0..21].* = "' from invalid value ".*; + ptr = formatIntDec(ptr[21..][0..32], value); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastToErrorFromInvalid( + comptime From: type, + type_name: []const u8, + value: From, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [512]u8 = undefined; // max_len: 9 + 64 + 7 + 1 + 32 + 2 + 80 = 195 (false branch) + buf[0..9].* = "cast to '".*; + var ptr: [*]u8 = cpyEquTrunc(buf[9..][0..64], type_name); + ptr[0..7].* = "' from ".*; + if (@typeInfo(From) == .Int) { + ptr[7..32].* = "non-existent error-code (".*; + ptr = formatIntDec(ptr[32..][0..32], value); + ptr[0] = ')'; + ptr += 1; + } else { + ptr[7] = '\''; + ptr = cpyEquTrunc(ptr[8..][0..32], @typeName(From)); + ptr[0..2].* = "' ".*; + ptr = formatAny(ptr[2..][0..80], value); + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastToIntFromInvalid( + comptime To: type, + to_type_name: []const u8, + comptime From: type, + from_type_name: []const u8, + extrema: std.meta.BestExtrema(To), + value: From, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (@typeInfo(From) == .Vector or @typeInfo(To) == .Vector or + (builtin.zig_backend != .stage2_llvm and @bitSizeOf(From) > 64)) + { + return panicImpl("integer part of floating point value out of bounds", null, ret_addr); + } + const yn: bool = value < 0; + var buf: [256]u8 = undefined; // max_len: 82 + 13 + 32 + 82 = 177 + var ptr: [*]u8 = writeCastToFrom(&buf, to_type_name, from_type_name); + ptr[0..13].* = " overflowed: ".*; + ptr = formatAny(ptr[13..][0..32], value); + ptr = writeAboveOrBelowLimit(ptr, std.meta.BestNum(To), to_type_name, yn, @intCast(if (yn) extrema.min else extrema.max)); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastTruncatedData( + comptime To: type, + to_type_name: []const u8, + comptime From: type, + from_type_name: []const u8, + extrema: std.meta.BestExtrema(To), + value: From, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (@typeInfo(From) == .Vector or @typeInfo(To) == .Vector or + (builtin.zig_backend != .stage2_llvm and @bitSizeOf(From) > 64)) + { + return panicImpl("cast truncated bits", null, ret_addr); + } + var buf: [256]u8 = undefined; // max_len: 82 + 17 + 32 + 82 = 213 + const yn: bool = value < 0; + var ptr: [*]u8 = writeCastToFrom(&buf, to_type_name, from_type_name); + ptr[0..17].* = " truncated bits: ".*; + ptr = formatIntDec(ptr[17..][0..32], value); + ptr = writeAboveOrBelowLimit(ptr, std.meta.BestNum(To), to_type_name, yn, @intCast(if (yn) extrema.min else extrema.max)); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicCastToUnsignedFromNegative( + comptime To: type, + to_type_name: []const u8, + comptime From: type, + from_type_name: []const u8, + value: From, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (@typeInfo(From) == .Vector or @typeInfo(To) == .Vector or + (builtin.zig_backend != .stage2_llvm and @bitSizeOf(From) > 64)) + { + return panicImpl("cast to unsigned from negative", null, ret_addr); + } + var buf: [256]u8 = undefined; // max_len: 82 + 18 + 32 + 1 = 133 + var ptr: [*]u8 = writeCastToFrom(&buf, to_type_name, from_type_name); + ptr[0..18].* = " lost signedness (".*; + ptr = formatIntDec(ptr[18..][0..32], value); + ptr[0] = ')'; + panicImpl(buf[0 .. @intFromPtr(ptr + 1) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicMismatchedSentinel( + comptime Number: type, + type_name: []const u8, + expected: Number, + found: Number, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (builtin.zig_backend != .stage2_llvm and (@bitSizeOf(Number) > 64)) { + return panicImpl("mismatched sentinel", null, ret_addr); + } + var buf: [256]u8 = undefined; // max_len: 32 + 29 + 80 + 8 + 80 = 229 + var ptr: [*]u8 = cpyEquTrunc(buf[0..32], type_name); + ptr[0..29].* = " sentinel mismatch: expected ".*; + ptr = formatAny(ptr[29..][0..80], expected); + ptr[0..8].* = ", found ".*; + ptr = formatAny(ptr[8..][0..80], found); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicAccessedInactiveField( + expected: []const u8, + found: []const u8, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + var buf: [512]u8 = undefined; // max_len: 23 + 80 + 15 + 80 + 11 = 209 + buf[0..23].* = "access of union field '".*; + var ptr: [*]u8 = cpyEquTrunc(buf[23..][0..80], found); + ptr[0..15].* = "' while field '".*; + ptr = cpyEquTrunc(ptr[15..][0..80], expected); + ptr[0..11].* = "' is active".*; + panicImpl(buf[0 .. @intFromPtr(ptr + 11) -% @intFromPtr(&buf)], null, ret_addr); +} +pub fn panicExactDivisionWithRemainder( + comptime Number: type, + lhs: Number, + rhs: Number, + ret_addr: usize, +) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (builtin.zig_backend != .stage2_llvm and @bitSizeOf(Number) > 64) { + return panicImpl("exact division with remainder", null, ret_addr); + } + var buf: [256]u8 = undefined; // max_len: 31 + 1 + 32 + 1 + 32 + 4 + 64 + 1 + 64 = 230 + buf[0..31].* = "exact division with remainder: ".*; + var ptr: [*]u8 = formatAny(buf[31..][0..32], lhs); + ptr[0] = '/'; + ptr = formatAny(ptr[1..][0..32], rhs); + ptr[0..4].* = " == ".*; + ptr = formatAny(ptr[4..][0..64], @divTrunc(lhs, rhs)); + ptr[0] = 'r'; + ptr = formatAny(ptr[1..][0..64], @rem(lhs, rhs)); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); +} +/// max_len: 9 + 32 + 8 + 32 + 1 = 82 +pub fn writeCastToFrom( + buf: [*]u8, + to_type_name: []const u8, + from_type_name: []const u8, +) [*]u8 { + @setRuntimeSafety(false); + buf[0..9].* = "cast to '".*; + const ptr: [*]u8 = cpyEquTrunc(buf[9..][0..32], to_type_name); + ptr[0..8].* = "' from '".*; + cpyEquTrunc(ptr[8..][0..32], from_type_name)[0] = '\''; + return ptr + 9 + from_type_name.len; +} +/// max_len: 7 + 32 + 10 + 32 + 1 = 82 +pub fn writeAboveOrBelowLimit( + buf: [*]u8, + comptime To: type, + to_type_name: []const u8, + yn: bool, + limit: To, +) [*]u8 { + @setRuntimeSafety(false); + buf[0..8].* = if (yn) " below '".* else " above '".*; + var ptr: [*]u8 = cpyEquTrunc(buf[8..][0..32], to_type_name); + ptr[0..11].* = if (yn) "' minimum (".* else "' maximum (".*; + ptr = formatIntDec(ptr[11..][0..32], limit); + ptr[0] = ')'; + return ptr + 1; +} + +pub fn panicArithOverflow(comptime Operand: type) type { + const Scalar = std.meta.Scalar(Operand); + const V = struct { + const Format = panicArithOverflow(Scalar); + const Absolute = @TypeOf(@abs(@as(Scalar, undefined))); + const Extrema = std.meta.BestExtrema(Scalar); + const len = @typeInfo(Operand).Vector.len; + const simplify = builtin.zig_backend != .stage2_llvm; + fn writeVecIdx(buf: [*]u8, idx: usize) [*]u8 { + @setRuntimeSafety(false); + buf[0..2].* = " [".*; + var ptr: [*]u8 = formatIntDec(buf[2..18], idx); + ptr[0..5].* = "] ".*; + return ptr + 5; + } + pub fn combined( + id: std.builtin.PanicId, + type_name: []const u8, + extrema: Extrema, + lhs: Operand, + rhs: Operand, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + const op_name = switch (id) { + .add_overflowed => panic_messages.add_overflowed, + .sub_overflowed => panic_messages.sub_overflowed, + .mul_overflowed => panic_messages.mul_overflowed, + else => panic_messages.div_overflowed, + }; + if (simplify) panicImpl(op_name, null, ret_addr); + var buf: [len * 384]u8 = undefined; + var ptr: [*]u8 = writeWhatOverflowed(&buf, type_name, op_name); + for (0..len) |idx| { + ptr = writeVecIdx(ptr, idx); + ptr = Format.writeCombined(ptr, id, type_name, extrema, lhs[idx], rhs[idx], false); + ptr[0] = '\n'; + ptr += 1; + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shl( + type_name: []const u8, + values: Operand, + shift_amts: [len]u16, + mask: Absolute, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (simplify) panicImpl(panic_messages.shl_overflowed, null, ret_addr); + var buf: [len * 384]u8 = undefined; + var ptr: [*]u8 = writeWhatOverflowed(&buf, type_name, "left shift overflowed"); + for (0..len) |idx| { + ptr = writeVecIdx(ptr, idx); + ptr = Format.writeShl(ptr, type_name, values[idx], shift_amts[idx], mask, false); + ptr[0] = '\n'; + ptr += 1; + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shr( + type_name: []const u8, + values: Operand, + shift_amts: [len]u16, + mask: Absolute, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (simplify) panicImpl(panic_messages.shr_overflowed, null, ret_addr); + var buf: [len * 384]u8 = undefined; + var ptr: [*]u8 = writeWhatOverflowed(&buf, type_name, "right shift overflowed"); + for (0..len) |idx| { + ptr = writeVecIdx(ptr, idx); + ptr = Format.writeShr(ptr, type_name, values[idx], shift_amts[idx], mask, false); + ptr[0] = '\n'; + ptr += 1; + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shiftRhs( + type_name: []const u8, + bit_count: u16, + shift_amts: [len]u16, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (simplify) panicImpl(panic_messages.shift_amt_overflowed, null, ret_addr); + var buf: [len * 384]u8 = undefined; + var ptr: [*]u8 = &buf; + for (0..len) |idx| { + ptr = writeVecIdx(ptr, idx); + ptr = Format.writeShiftRhs(ptr, type_name, bit_count, shift_amts[idx]); + ptr[0] = '\n'; + ptr += 1; + } + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + fn writeWhatOverflowed( + buf: [*]u8, + type_name: []const u8, + op_name: []const u8, + ) [*]u8 { + @setRuntimeSafety(false); + var ptr: [*]u8 = cpyEqu(buf, op_name); + ptr[0..2].* = " '".*; + ptr = cpyEquTrunc(ptr[1..][0..16], type_name); + ptr[0..3].* = "':\n".*; + return ptr + 2; + } + }; + const S = struct { + const Extrema = std.meta.BestExtrema(Operand); + const Absolute = @TypeOf(@abs(@as(Operand, undefined))); + const large: bool = @bitSizeOf(Operand) > 64; + pub fn combined( + id: std.builtin.PanicId, + type_name: []const u8, + extrema: Extrema, + lhs: Operand, + rhs: Operand, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (large) panicImpl(switch (id) { + .add_overflowed => panic_messages.add_overflowed, + .sub_overflowed => panic_messages.sub_overflowed, + .mul_overflowed => panic_messages.mul_overflowed, + else => panic_messages.div_overflowed, + }, null, ret_addr); + var buf: [256]u8 = undefined; + const ptr: [*]u8 = writeCombined(&buf, id, type_name, extrema, lhs, rhs, true); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shl( + type_name: []const u8, + value: Operand, + shift_amt: u16, + mask: Absolute, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (large) panicImpl(panic_messages.shl_overflowed, null, ret_addr); + var buf: [256]u8 = undefined; + const ptr: [*]u8 = writeShl(&buf, type_name, value, shift_amt, mask, true); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shr( + type_name: []const u8, + value: Operand, + shift_amt: u16, + mask: Absolute, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (large) panicImpl(panic_messages.shr_overflowed, null, ret_addr); + var buf: [256]u8 = undefined; + const ptr: [*]u8 = writeShr(&buf, type_name, value, shift_amt, mask, true); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn shiftRhs( + type_name: []const u8, + bit_count: u16, + shift_amt: u16, + ret_addr: usize, + ) noreturn { + @setCold(true); + @setRuntimeSafety(false); + if (large) panicImpl(panic_messages.shift_amt_overflowed, null, ret_addr); + var buf: [256]u8 = undefined; + const ptr: [*]u8 = writeShiftRhs(&buf, type_name, bit_count, shift_amt); + panicImpl(buf[0 .. @intFromPtr(ptr) -% @intFromPtr(&buf)], null, ret_addr); + } + pub fn writeCombined( + buf: [*]u8, + id: std.builtin.PanicId, + type_name: []const u8, + extrema: Extrema, + lhs: Operand, + rhs: Operand, + what: bool, + ) [*]u8 { + @setRuntimeSafety(false); + const yn: bool = switch (id) { + .add_overflowed => rhs < 0, + .sub_overflowed => rhs > 0, + else => @bitCast( + (@intFromBool(rhs < 0) & @intFromBool(lhs > 0)) | + (@intFromBool(lhs < 0) & @intFromBool(rhs > 0)), + ), + }; + const ptr: [*]u8 = writeOverflowed(buf, switch (id) { + .add_overflowed => panic_messages.add_overflowed, + .sub_overflowed => panic_messages.sub_overflowed, + .mul_overflowed => panic_messages.mul_overflowed, + else => panic_messages.div_overflowed, + }, type_name, switch (id) { + .add_overflowed => " + ", + .sub_overflowed => " - ", + .mul_overflowed => " * ", + else => " / ", + }, lhs, rhs, switch (id) { + .add_overflowed => @addWithOverflow(lhs, rhs), + .sub_overflowed => @subWithOverflow(lhs, rhs), + .mul_overflowed => @mulWithOverflow(lhs, rhs), + else => null, + }, what); + return writeAboveOrBelowLimit(ptr, Operand, type_name, yn, if (yn) extrema.min else extrema.max); + } + pub fn writeShl( + buf: [*]u8, + type_name: []const u8, + value: Operand, + shift_amt: u16, + mask: Absolute, + what: bool, + ) [*]u8 { + @setCold(true); + @setRuntimeSafety(false); + const absolute: Absolute = @bitCast(value); + const a_pc: u16 = @popCount(absolute & mask); + const b_pc: u16 = @popCount((absolute << @intCast(shift_amt)) & mask); + var ptr: [*]u8 = buf; + if (what) { + ptr[0..23].* = "left shift overflowed '".*; + ptr = cpyEquTrunc(ptr[23..][0..16], type_name); + ptr[0..3].* = "': ".*; + ptr += 3; + } + ptr = formatIntDec(ptr[0..32], value); + ptr[0..4].* = " << ".*; + ptr = formatIntDec(ptr[4..][0..32], @as(usize, shift_amt)); + if (a_pc <= b_pc) return ptr; + return writeShiftedOutBits(ptr, a_pc -% b_pc); + } + pub fn writeShr( + buf: [*]u8, + type_name: []const u8, + value: Operand, + shift_amt: u16, + mask: Absolute, + what: bool, + ) [*]u8 { + @setCold(true); + @setRuntimeSafety(false); + const absolute: Absolute = @bitCast(value); + const a_pc: u16 = @popCount(absolute & mask); + const b_pc: u16 = @popCount((absolute >> @intCast(shift_amt)) & mask); + var ptr: [*]u8 = buf; + if (what) { + ptr[0..24].* = "right shift overflowed '".*; + ptr = cpyEquTrunc(ptr[24..][0..16], type_name); + ptr[0..3].* = "': ".*; + ptr += 3; + } + ptr = formatIntDec(ptr[0..32], value); + ptr[0..4].* = " >> ".*; + ptr = formatIntDec(ptr[4..][0..32], @as(usize, shift_amt)); + if (a_pc <= b_pc) return ptr; + return writeShiftedOutBits(ptr, a_pc -% b_pc); + } + pub fn writeShiftRhs( + buf: [*]u8, + type_name: []const u8, + bit_count: u16, + shift_amt: u16, + ) [*]u8 { + @setCold(true); + @setRuntimeSafety(false); + buf[0..18].* = "shift overflowed '".*; + var ptr: [*]u8 = cpyEquTrunc(buf[18..][0..16], type_name); + ptr[0..17].* = "': shift amount (".*; + ptr = formatIntDec(ptr[17..][0..32], @as(usize, shift_amt)); + ptr[0..35].* = ") above bit width of integer type (".*; + ptr = formatIntDec(ptr[35..][0..32], @as(usize, bit_count)); + ptr[0] = ')'; + return ptr + 1; + } + pub fn writeOverflowed( + buf: [*]u8, + op_name: []const u8, + type_name: []const u8, + op_sym: *const [3]u8, + lhs: Operand, + rhs: Operand, + res_opt: ?struct { Operand, u1 }, + what: bool, + ) [*]u8 { + @setCold(true); + @setRuntimeSafety(false); + var ptr: [*]u8 = buf; + if (what) { + ptr = cpyEqu(ptr, op_name); + ptr[0..2].* = " '".*; + ptr = cpyEquTrunc(ptr[2..18], type_name); + ptr[0..3].* = "': ".*; + ptr += 3; + } + ptr = formatIntDec(ptr[0..32], lhs); + ptr[0..3].* = op_sym.*; + ptr = formatIntDec(ptr[3..][0..32], rhs); + if (res_opt) |res| { + if (res[1] == 0) { + ptr[0..2].* = " (".*; + ptr = formatIntDec(ptr[2..][0..32], res[0]); + ptr[0] = ')'; + ptr += 1; + } + } + return ptr; + } + pub fn writeShiftedOutBits( + buf: [*]u8, + ov_bits: u16, + ) [*]u8 { + @setCold(true); + @setRuntimeSafety(false); + buf[0..13].* = " shifted-out ".*; + var ptr: [*]u8 = formatIntDec(buf[13..][0..32], @as(usize, ov_bits)); + ptr[0..5].* = " bits".*; + return ptr + 4 + @intFromBool(ov_bits != 1); + } + }; + return if (Scalar != Operand) V else S; +} + +fn cpyEquTrunc(slice: []u8, str: []const u8) [*]u8 { + if (str.len > slice.len) { + _ = cpyEqu(slice.ptr, str[0..slice.len]); + (slice.ptr - 4)[slice.len..][0..4].* = "[..]".*; + return slice.ptr + slice.len; + } else { + return cpyEqu(slice.ptr, str); + } +} +fn cpyEqu(ptr: [*]u8, str: []const u8) [*]u8 { + for (str, 0..) |byte, idx| ptr[idx] = byte; + return ptr + str.len; +} +fn writeErrorFormattingValue(buf: []u8) [*]u8 { + if (buf.len < 24) { + return cpyEqu(buf.ptr, "???"[0..@min(buf.len, 3)]); + } + return cpyEqu(buf.ptr, "(error formatting value)"); +} +fn formatAny(buf: []u8, value: anytype) [*]u8 { + var fbs = std.io.fixedBufferStream(buf); + std.fmt.format(fbs.writer(), "{any}", .{value}) catch { + return writeErrorFormattingValue(buf); + }; + return buf.ptr + fbs.pos; +} +fn formatIntDec(buf: []u8, value: anytype) [*]u8 { + return buf.ptr + std.fmt.formatIntBuf(buf, value, 10, .lower, .{}); +} +fn formatIntHex(buf: []u8, value: anytype) [*]u8 { + return buf.ptr + std.fmt.formatIntBuf(buf, value, 16, .lower, .{}); +} + +pub const panic_messages = struct { + pub const message = undefined; + pub const unwrapped_error = "attempt to unwrap error"; + pub const returned_noreturn = "'noreturn' function returned"; + pub const reached_unreachable = "reached unreachable code"; + pub const corrupt_switch = "switch on corrupt value"; + pub const accessed_out_of_bounds = "index out of bounds"; + pub const accessed_out_of_order = "start index is larger than end index"; + pub const accessed_out_of_order_extra = accessed_out_of_bounds ++ " or " ++ accessed_out_of_order; + pub const accessed_inactive_field = "access of inactive union field"; + pub const accessed_null_value = "attempt to use null value"; + pub const divided_by_zero = "division by zero"; + pub const memcpy_argument_aliasing = "@memcpy arguments alias"; + pub const mismatched_memcpy_argument_lengths = "@memcpy arguments have non-equal lengths"; + pub const mismatched_for_loop_capture_lengths = "for loop over objects with non-equal lengths"; + pub const mismatched_sentinel = "sentinel mismatch"; + pub const mismatched_null_sentinel = "mismatched null terminator"; + pub const shl_overflowed = "left shift overflowed bits"; + pub const shr_overflowed = "right shift overflowed bits"; + pub const shift_amt_overflowed = "shift amount is greater than the type size"; + pub const div_with_remainder = "exact division produced remainder"; + pub const mul_overflowed = "mul overflowed"; + pub const add_overflowed = "add overflowed"; + pub const sub_overflowed = "sub overflowed"; + pub const div_overflowed = "div overflowed"; + pub const cast_truncated_data = "integer cast truncated bits"; + pub const cast_to_enum_from_invalid = "invalid enum value"; + pub const cast_to_error_from_invalid = "invalid error code"; + pub const cast_to_ptr_from_invalid = "cast to invalid pointer"; + pub const cast_to_int_from_invalid = "integer part of floating point value out of bounds"; + pub const cast_to_unsigned_from_negative = "cast to unsigned integer from negative value"; +}; + test { _ = &dump_hex; } diff --git a/lib/std/math/nextafter.zig b/lib/std/math/nextafter.zig index 717cbf470070..83caeadb84b0 100644 --- a/lib/std/math/nextafter.zig +++ b/lib/std/math/nextafter.zig @@ -112,7 +112,8 @@ test "int" { try expect(nextAfter(u1, 0, 1) == 1); try expect(nextAfter(u1, 1, 1) == 1); try expect(nextAfter(u1, 1, 0) == 0); - inline for (.{ i8, i16, i32, i64, i128, i333 }) |T| { + const i_big = if (@import("builtin").zig_backend != .stage2_c) [1]type{i333} else [0]type{}; + inline for (.{ i8, i16, i32, i64, i128 } ++ i_big) |T| { try expect(nextAfter(T, 3, 7) == 4); try expect(nextAfter(T, 3, -7) == 2); try expect(nextAfter(T, -3, -7) == -4); @@ -123,7 +124,8 @@ test "int" { try expect(nextAfter(T, math.minInt(T), math.minInt(T)) == math.minInt(T)); try expect(nextAfter(T, math.maxInt(T), math.maxInt(T)) == math.maxInt(T)); } - inline for (.{ u8, u16, u32, u64, u128, u333 }) |T| { + const u_big = if (@import("builtin").zig_backend != .stage2_c) [1]type{u333} else [0]type{}; + inline for (.{ u8, u16, u32, u64, u128 } ++ u_big) |T| { try expect(nextAfter(T, 3, 7) == 4); try expect(nextAfter(T, 7, 3) == 6); try expect(nextAfter(T, 5, 5) == 5); diff --git a/lib/std/meta.zig b/lib/std/meta.zig index 13c7731c5514..8a8d083be8e6 100644 --- a/lib/std/meta.zig +++ b/lib/std/meta.zig @@ -126,6 +126,37 @@ test Elem { try testing.expect(Elem(?[*]u8) == u8); } +/// Given a vector type, return the scalar type. Given a scalar type, return +/// that type. +pub fn Scalar(comptime T: type) type { + switch (@typeInfo(T)) { + .Vector => |info| { + return info.child; + }, + .Bool, .Int, .Float => { + return T; + }, + .Pointer => |info| { + if (info.size != .Slice) { + return T; + } + }, + else => {}, + } + @compileError("Expected vector, boolean, integer, pointer, or float type, found '" ++ @typeName(T) ++ "'"); +} + +test Scalar { + try testing.expect(Scalar(u8) == u8); + try testing.expect(Scalar(*u8) == *u8); + try testing.expect(Scalar(bool) == bool); + try testing.expect(Scalar(f32) == f32); + try testing.expect(Scalar(@Vector(1, u8)) == u8); + try testing.expect(Scalar(@Vector(1, *u8)) == *u8); + try testing.expect(Scalar(@Vector(1, bool)) == bool); + try testing.expect(Scalar(@Vector(1, f32)) == f32); +} + /// Given a type which can have a sentinel e.g. `[:0]u8`, returns the sentinel value, /// or `null` if there is not one. /// Types which cannot possibly have a sentinel will be a compile error. @@ -1286,3 +1317,97 @@ test hasUniqueRepresentation { try testing.expect(hasUniqueRepresentation(@Vector(std.simd.suggestVectorLength(u8) orelse 1, u8))); try testing.expect(@sizeOf(@Vector(3, u8)) == 3 or !hasUniqueRepresentation(@Vector(3, u8))); } + +// Whether these are better suited to `math` or `meta` is questionable. +// +// The only real purpose of these functions is type erasure. + +pub fn BestFloat(comptime F: type) type { + switch (@typeInfo(F)) { + .Vector => |vector_info| { + return @Vector(vector_info.len, BestFloat(vector_info.child)); + }, + .Float => |float_info| { + return if (float_info.bits <= 64) f64 else f128; + }, + else => { + @compileError("Expected float or vector type, found '" ++ @typeName(Float) ++ "'"); + }, + } +} +pub fn BestInt(comptime I: type) type { + switch (@typeInfo(I)) { + .Vector => |vector_info| { + return @Vector(vector_info.len, BestInt(vector_info.child)); + }, + .Int => |int_info| if (@bitSizeOf(I) <= @bitSizeOf(usize)) { + if (@typeInfo(I).Int.signedness == .signed) { + return isize; + } else { + return usize; + } + } else { + return @Type(.{ .Int = .{ + .bits = 1 << (15 - (@clz(int_info.bits) - + @intFromBool(@popCount(int_info.bits) != 1))), + .signedness = int_info.signedness, + } }); + }, + else => { + @compileError("Expected integer or vector type, found '" ++ @typeName(I) ++ "'"); + }, + } +} +pub fn BestNum(comptime N: type) type { + switch (@typeInfo(N)) { + .ComptimeInt, .Int => { + return BestInt(N); + }, + .ComptimeFloat, .Float => { + return BestFloat(N); + }, + else => return N, + } +} +/// Informs the return type of `bestExtrema`. +pub fn BestExtrema(comptime I: type) type { + if (@typeInfo(I) == .Vector) { + return BestExtrema(BestInt(@typeInfo(I).Vector.child)); + } + if (I != BestInt(I)) { + return BestExtrema(BestInt(I)); + } + return struct { min: I, max: I }; +} +/// Stores the minimum and maximum values of type `I` in the best common +/// type with the same sign (usually `usize` or `isize`). +pub inline fn bestExtrema(comptime I: type) BestExtrema(I) { + comptime { + switch (@typeInfo(I)) { + .Vector => return bestExtrema(@typeInfo(I).Vector.child), + .Int => switch (I) { + u0, i0 => return .{ .min = 0, .max = 0 }, + u1 => return .{ .min = 0, .max = 1 }, + i1 => return .{ .min = -1, .max = 0 }, + else => { + const U = @Type(.{ .Int = .{ + .signedness = .unsigned, + .bits = @bitSizeOf(I), + } }); + const umax: U = ~@as(U, 0); + if (@typeInfo(I).Int.signedness == .unsigned) { + return .{ .min = 0, .max = umax }; + } else { + const imax: U = umax >> 1; + return .{ + .min = @as(I, @bitCast(~imax)), + .max = @as(I, @bitCast(imax)), + }; + } + }, + }, + else => {}, + } + @compileError("Expected integer or vector type, found '" ++ @typeName(I) ++ "'"); + } +} diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig index d7327f8bee96..5fe9374e2314 100644 --- a/lib/std/multi_array_list.zig +++ b/lib/std/multi_array_list.zig @@ -71,17 +71,16 @@ pub fn MultiArrayList(comptime T: type) type { pub fn items(self: Slice, comptime field: Field) []FieldType(field) { const F = FieldType(field); + var ret: []F = &[0]F{}; if (self.capacity == 0) { - return &[_]F{}; + return ret; } - const byte_ptr = self.ptrs[@intFromEnum(field)]; - const casted_ptr: [*]F = if (@sizeOf(F) == 0) - undefined - else - @ptrCast(@alignCast(byte_ptr)); - return casted_ptr[0..self.len]; + ret.len = self.len; + if (@sizeOf(F) != 0) { + ret.ptr = @ptrCast(@alignCast(self.ptrs[@intFromEnum(field)])); + } + return ret; } - pub fn set(self: *Slice, index: usize, elem: T) void { const e = switch (@typeInfo(T)) { .Struct => elem, diff --git a/src/Compilation.zig b/src/Compilation.zig index 03b981812e35..b969fc0d814f 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -1327,6 +1327,7 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil cache_helpers.addOptionalEmitLoc(&cache.hash, options.emit_docs); cache.hash.addBytes(options.root_name); cache.hash.add(options.config.wasi_exec_model); + // TODO audit this and make sure everything is in it const main_mod = options.main_mod orelse options.root_mod; @@ -4609,10 +4610,14 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P // Just to save disk space, we delete the files that are never needed again. defer if (out_diag_path) |diag_file_path| zig_cache_tmp_dir.deleteFile(std.fs.path.basename(diag_file_path)) catch |err| { - log.warn("failed to delete '{s}': {s}", .{ diag_file_path, @errorName(err) }); + if (err != error.FileNotFound) { + log.warn("failed to delete '{s}': {s}", .{ diag_file_path, @errorName(err) }); + } }; defer if (out_dep_path) |dep_file_path| zig_cache_tmp_dir.deleteFile(std.fs.path.basename(dep_file_path)) catch |err| { - log.warn("failed to delete '{s}': {s}", .{ dep_file_path, @errorName(err) }); + if (err != error.FileNotFound) { + log.warn("failed to delete '{s}': {s}", .{ dep_file_path, @errorName(err) }); + } }; if (std.process.can_spawn) { var child = std.process.Child.init(argv.items, arena); diff --git a/src/Module.zig b/src/Module.zig index c571c851fe57..202ee5d600ea 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -171,10 +171,19 @@ reference_table: std.AutoHashMapUnmanaged(Decl.Index, struct { src: LazySrcLoc, }) = .{}, -panic_messages: [PanicId.len]Decl.OptionalIndex = .{.none} ** PanicId.len, -/// The panic function body. -panic_func_index: InternPool.Index = .none, -null_stack_trace: InternPool.Index = .none, +safety: struct { + panic_fn_sig: enum { none, generic, simple } = .none, + + panic_fn_inst: Air.Inst.Ref = .none, + panic_data_fn_inst: Air.Inst.Ref = .none, + + panic_cause_ty: InternPool.Index = .none, + panic_cast_ty: InternPool.Index = .none, + panic_id_ty: InternPool.Index = .none, + + fn_cache: [128]InternPool.Index = .{.none} ** 128, + ty_cache: [128]InternPool.Index = .{.none} ** 128, +} = .{}, pub const PanicId = enum { unreach, diff --git a/src/Sema.zig b/src/Sema.zig index ca6d562eef51..20b047199e62 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -805,7 +805,7 @@ pub const Block = struct { fn addUnreachable(block: *Block, src: LazySrcLoc, safety_check: bool) !void { if (safety_check and block.wantSafety()) { - try block.sema.safetyPanic(block, src, .unreach); + try RuntimeSafety.panicReachedUnreachable(block.sema, block, src, .reached_unreachable); } else { _ = try block.addNoOp(.unreach); } @@ -2494,7 +2494,7 @@ pub fn failWithOwnedErrorMsg(sema: *Sema, block: ?*Block, err_msg: *Module.Error std.debug.print("compile error during Sema:\n", .{}); var error_bundle = wip_errors.toOwnedBundle("") catch unreachable; error_bundle.renderToStdErr(.{ .ttyconf = .no_color }); - crash_report.compilerPanic("unexpected compile error occurred", null, null); + crash_report.compilerPanicSimple("unexpected compile error occurred"); } try mod.failed_decls.ensureUnusedCapacity(gpa, 1); @@ -4499,7 +4499,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. if (arg_len == .none) continue; if (i == len_idx) continue; const ok = try block.addBinOp(.cmp_eq, len, arg_len); - try sema.addSafetyCheck(block, src, ok, .for_len_mismatch); + try RuntimeSafety.checkMismatchedForLoopCaptureLengths(sema, block, src, len, arg_len, ok); } } @@ -5902,7 +5902,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void if (block.is_comptime) { return sema.fail(block, src, "encountered @panic at comptime", .{}); } - try sema.panicWithMsg(block, src, coerced_msg, .@"@panic"); + try RuntimeSafety.panicWithMsg(sema, block, src, coerced_msg, .@"@panic"); } fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { @@ -8040,7 +8040,7 @@ fn analyzeCall( else => {}, } } - try sema.safetyPanic(block, call_src, .noreturn_returned); + try RuntimeSafety.panicReachedUnreachable(sema, block, call_src, .returned_noreturn); return .unreachable_value; } if (func_ty_info.return_type == .noreturn_type) { @@ -8666,6 +8666,11 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil const sentinel_val = try sema.resolveConstDefinedValue(block, sentinel_src, sentinel, .{ .needed_comptime_reason = "array sentinel value must be comptime-known", }); + if (!elem_type.allowsSentinel(sema.mod)) { + return sema.fail(block, sentinel_src, "sentinel not allowed for aggregate of non-scalar type '{}'", .{ + elem_type.fmt(sema.mod), + }); + } const array_ty = try sema.mod.arrayType(.{ .len = len, .sentinel = sentinel_val.toIntern(), @@ -8824,7 +8829,7 @@ fn zirErrorFromInt(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD const zero_val = Air.internedToRef((try mod.intValue(err_int_ty, 0)).toIntern()); const is_non_zero = try block.addBinOp(.cmp_neq, operand, zero_val); const ok = try block.addBinOp(.bool_and, is_lt_len, is_non_zero); - try sema.addSafetyCheck(block, src, ok, .invalid_error_code); + try RuntimeSafety.checkCastToErrorFromInvalid(sema, block, src, Type.anyerror, err_int_ty, operand, ok); } return block.addInst(.{ .tag = .bitcast, @@ -9012,11 +9017,12 @@ fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError try sema.requireRuntimeBlock(block, src, operand_src); const result = try block.addTyOp(.intcast, dest_ty, operand); + if (block.wantSafety() and !dest_ty.isNonexhaustiveEnum(mod) and mod.backendSupportsFeature(.is_named_enum_value)) { const ok = try block.addUnOp(.is_named_enum_value, result); - try sema.addSafetyCheck(block, src, ok, .invalid_enum_value); + try RuntimeSafety.checkCastToEnumFromInvalid(sema, block, src, dest_ty, operand, ok); } return result; } @@ -9093,7 +9099,7 @@ fn analyzeOptionalPayloadPtr( try sema.requireRuntimeBlock(block, src, null); if (safety_check and block.wantSafety()) { const is_non_null = try block.addUnOp(.is_non_null_ptr, optional_ptr); - try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null); + try RuntimeSafety.checkAccessNullValue(sema, block, src, is_non_null); } if (initializing) { @@ -9153,7 +9159,7 @@ fn zirOptionalPayload( try sema.requireRuntimeBlock(block, src, null); if (safety_check and block.wantSafety()) { const is_non_null = try block.addUnOp(.is_non_null, operand); - try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null); + try RuntimeSafety.checkAccessNullValue(sema, block, src, is_non_null); } return block.addTyOp(.optional_payload, result_ty, operand); } @@ -9205,7 +9211,7 @@ fn analyzeErrUnionPayload( if (safety_check and block.wantSafety() and !err_union_ty.errorUnionSet(mod).errorSetIsEmpty(mod)) { - try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err, .is_non_err); + try RuntimeSafety.checkUnwrappedError(sema, block, src, operand, .unwrap_errunion_err, .is_non_err); } return block.addTyOp(.unwrap_errunion_payload, payload_ty, operand); @@ -9288,7 +9294,7 @@ fn analyzeErrUnionPayloadPtr( if (safety_check and block.wantSafety() and !err_union_ty.errorUnionSet(zcu).errorSetIsEmpty(zcu)) { - try sema.panicUnwrapError(block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr); + try RuntimeSafety.checkUnwrappedError(sema, block, src, operand, .unwrap_errunion_err_ptr, .is_non_err_ptr); } if (initializing) { @@ -10491,7 +10497,7 @@ fn intCast( const is_in_range = try block.addBinOp(.cmp_lte, operand, zero_inst); break :ok is_in_range; }; - try sema.addSafetyCheck(block, src, ok, .cast_truncated_data); + try RuntimeSafety.checkCastTruncatedData(sema, block, src, dest_ty, operand_ty, operand, ok); } } @@ -10554,7 +10560,7 @@ fn intCast( break :ok is_in_range; }; // TODO negative_to_unsigned? - try sema.addSafetyCheck(block, src, ok, .cast_truncated_data); + try RuntimeSafety.checkCastTruncatedData(sema, block, src, dest_ty, operand_ty, operand, ok); } else { const ok = if (is_vector) ok: { const is_in_range = try block.addCmpVector(operand, dest_max, .lte); @@ -10570,7 +10576,7 @@ fn intCast( const is_in_range = try block.addBinOp(.cmp_lte, operand, dest_max); break :ok is_in_range; }; - try sema.addSafetyCheck(block, src, ok, .cast_truncated_data); + try RuntimeSafety.checkCastTruncatedData(sema, block, src, dest_ty, operand_ty, operand, ok); } } else if (actual_info.signedness == .signed and wanted_info.signedness == .unsigned) { // no shrinkage, yes sign loss @@ -10593,7 +10599,7 @@ fn intCast( const is_in_range = try block.addBinOp(.cmp_gte, operand, zero_inst); break :ok is_in_range; }; - try sema.addSafetyCheck(block, src, ok, .negative_to_unsigned); + try RuntimeSafety.checkCastToUnsignedFromNegative(sema, block, src, dest_ty, operand_ty, operand, ok); } } return block.addTyOp(.intcast, dest_ty, operand); @@ -10921,78 +10927,789 @@ fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile return sema.elemPtr(block, src, array_ptr, elem_index, src, true, true); } -fn zirSliceStart(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { +fn zirSliceStart(sema: *Sema, block: *Sema.Block, inst: Zir.Inst.Index) !Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; - const src = inst_data.src(); - const extra = sema.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data; - const array_ptr = try sema.resolveInst(extra.lhs); - const start = try sema.resolveInst(extra.start); - const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; + const src: LazySrcLoc = inst_data.src(); + const extra: Zir.Inst.SliceStart = sema.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data; + const array_ptr: Air.Inst.Ref = try sema.resolveInst(extra.lhs); const start_src: LazySrcLoc = .{ .node_offset_slice_start = inst_data.src_node }; + const start: Air.Inst.Ref = try sema.coerce(block, Type.usize, try sema.resolveInst(extra.start), start_src); + const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; const end_src: LazySrcLoc = .{ .node_offset_slice_end = inst_data.src_node }; - - return sema.analyzeSlice(block, src, array_ptr, start, .none, .none, .unneeded, ptr_src, start_src, end_src, false); + return analyzeSlice2(sema, block, .{}, src, array_ptr, Type.void, start, .none, .none, .none, ptr_src, start_src, end_src, .unneeded, .slice_start); } - -fn zirSliceEnd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { +fn zirSliceEnd(sema: *Sema, block: *Sema.Block, inst: Zir.Inst.Index) !Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; - const src = inst_data.src(); - const extra = sema.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data; - const array_ptr = try sema.resolveInst(extra.lhs); - const start = try sema.resolveInst(extra.start); - const end = try sema.resolveInst(extra.end); - const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; + const src: LazySrcLoc = inst_data.src(); + const extra: Zir.Inst.SliceEnd = sema.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data; + const array_ptr: Air.Inst.Ref = try sema.resolveInst(extra.lhs); const start_src: LazySrcLoc = .{ .node_offset_slice_start = inst_data.src_node }; + const start: Air.Inst.Ref = try sema.coerce(block, Type.usize, try sema.resolveInst(extra.start), start_src); + const end: Air.Inst.Ref = try sema.resolveInst(extra.end); + const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; const end_src: LazySrcLoc = .{ .node_offset_slice_end = inst_data.src_node }; - - return sema.analyzeSlice(block, src, array_ptr, start, end, .none, .unneeded, ptr_src, start_src, end_src, false); + return analyzeSlice2(sema, block, .{}, src, array_ptr, Type.void, start, end, .none, .none, ptr_src, start_src, end_src, .unneeded, .slice_end); } - -fn zirSliceSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { +fn zirSliceSentinel(sema: *Sema, block: *Sema.Block, inst: Zir.Inst.Index) !Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; const src = inst_data.src(); - const sentinel_src: LazySrcLoc = .{ .node_offset_slice_sentinel = inst_data.src_node }; - const extra = sema.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data; - const array_ptr = try sema.resolveInst(extra.lhs); - const start = try sema.resolveInst(extra.start); + const extra: Zir.Inst.SliceSentinel = sema.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data; + const array_ptr: Air.Inst.Ref = try sema.resolveInst(extra.lhs); + const start_src: LazySrcLoc = .{ .node_offset_slice_start = inst_data.src_node }; + const start: Air.Inst.Ref = try sema.coerce(block, Type.usize, try sema.resolveInst(extra.start), start_src); const end: Air.Inst.Ref = if (extra.end == .none) .none else try sema.resolveInst(extra.end); - const sentinel = try sema.resolveInst(extra.sentinel); + const sentinel: Air.Inst.Ref = try sema.resolveInst(extra.sentinel); const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; - const start_src: LazySrcLoc = .{ .node_offset_slice_start = inst_data.src_node }; const end_src: LazySrcLoc = .{ .node_offset_slice_end = inst_data.src_node }; - - return sema.analyzeSlice(block, src, array_ptr, start, end, sentinel, sentinel_src, ptr_src, start_src, end_src, false); + const sentinel_src: LazySrcLoc = .{ .node_offset_slice_sentinel = inst_data.src_node }; + return analyzeSlice2(sema, block, .{}, src, array_ptr, Type.void, start, end, .none, sentinel, ptr_src, start_src, end_src, sentinel_src, .slice_sentinel); } - -fn zirSliceLength(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { +fn zirSliceLength(sema: *Sema, block: *Sema.Block, inst: Zir.Inst.Index) !Air.Inst.Ref { const tracy = trace(@src()); defer tracy.end(); const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; const src = inst_data.src(); - const extra = sema.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data; - const array_ptr = try sema.resolveInst(extra.lhs); - const start = try sema.resolveInst(extra.start); - const len = try sema.resolveInst(extra.len); - const sentinel = if (extra.sentinel == .none) .none else try sema.resolveInst(extra.sentinel); + const extra: Zir.Inst.SliceLength = sema.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data; + const array_ptr: Air.Inst.Ref = try sema.resolveInst(extra.lhs); + const len: Air.Inst.Ref = try sema.resolveInst(extra.len); const ptr_src: LazySrcLoc = .{ .node_offset_slice_ptr = inst_data.src_node }; const start_src: LazySrcLoc = .{ .node_offset_slice_start = extra.start_src_node_offset }; + const start: Air.Inst.Ref = try sema.coerce(block, Type.usize, try sema.resolveInst(extra.start), start_src); + const sentinel: Air.Inst.Ref = if (extra.sentinel == .none) .none else try sema.resolveInst(extra.sentinel); + const sentinel_src: LazySrcLoc = if (sentinel == .none) .unneeded else .{ .node_offset_slice_sentinel = inst_data.src_node }; const end_src: LazySrcLoc = .{ .node_offset_slice_end = inst_data.src_node }; - const sentinel_src: LazySrcLoc = if (sentinel == .none) - .unneeded - else - .{ .node_offset_slice_sentinel = inst_data.src_node }; + const end: Air.Inst.Ref = try sema.analyzeArithmetic(block, .addwrap, start, len, src, start_src, end_src, false); + return analyzeSlice2(sema, block, .{}, src, array_ptr, Type.void, start, end, len, sentinel, ptr_src, start_src, end_src, sentinel_src, .slice_length); +} + +const SliceAnalysis = packed struct(u32) { + // States of input values. + src_ptr: State = .variable, + src_len: State = .unknown, + src_sent: State = .unknown, + + // States of derived values. + dest_ptr: State = .variable, + dest_start: State = .variable, + dest_end: State = .unknown, + dest_len: State = .unknown, + dest_sent: State = .unknown, + + // States of checks with runtime component. + start_le_len: State = .unknown, + start_le_end: State = .unknown, + end_le_len: State = .unknown, + eq_sentinel: State = .unknown, + ptr_ne_null: State = .unknown, + + reserved: u6 = 0, + + /// This type is used to track the theoretical `comptime`-ness of values. + /// The theory is that the result of any binary operation will inherit the + /// state of the least-known operand. + const State = enum(u2) { + unknown = 0, + variable = 1, + known = 2, + fn min(arg1: State, arg2: State) State { + return @enumFromInt(@min(@intFromEnum(arg1), @intFromEnum(arg2))); + } + }; + // TODO: Remove `slice_sentinel`. Make `slice_start` and `slice_end` behave + // like `slice_length` if possible (sentinel optional). Clearly + // indicating the base syntax is significant for the simplicity of + // `Sema.analyzeSlice2`. + // + // TODO: Remove this entirely. + const Op = enum(u32) { + slice_start = @intFromEnum(Zir.Inst.Tag.slice_start), + slice_end = @intFromEnum(Zir.Inst.Tag.slice_end), + slice_sentinel = @intFromEnum(Zir.Inst.Tag.slice_sentinel), + slice_length = @intFromEnum(Zir.Inst.Tag.slice_length), + }; +}; +/// ATTENTION: Remove this behaviour as soon as possible. +const feature_allow_slice_to_sentinel: bool = true; +/// ATTENTION: Remove this behaviour as soon as possible. +const feature_allow_limited_slice_of_undefined: bool = true; +// TODO: Complete this feature. The goal is to prevent the user from slicing +// pointer-to-many to create pointers out of bounds of the containing +// declaration. In other words replaces a potential panic (in ReleaseSafe) +// or UB (in ReleaseFast) with a compile error. +// +// * Do something about error union and optional payloads. +// * Do something about compile-time-known pointers-to-array with incorrect +// lengths. That 'something' can be in `analyzeSlice2`, but is better in +// safety checks for `@ptrCast`. +// +const feature_prevent_inval_ptr: bool = true; +/// TODO: This is technically a concern, but is not worth the effort/cost. +const feature_prevent_impossible_sent: bool = true; + +fn analyzeSlice2( + sema: *Sema, + block: *Block, + flags: Zir.Inst.FullPtrCastFlags, + src: LazySrcLoc, + operand: Air.Inst.Ref, + dest_ty: Type, + dest_start: Air.Inst.Ref, + uncasted_dest_end_opt: Air.Inst.Ref, + uncasted_dest_len_opt: Air.Inst.Ref, + dest_sent_opt: Air.Inst.Ref, + operand_src: LazySrcLoc, + dest_start_src: LazySrcLoc, + dest_end_src: LazySrcLoc, + dest_sent_src: LazySrcLoc, + kind: SliceAnalysis.Op, +) !Air.Inst.Ref { + var src_ptr_ty: Type = sema.typeOf(operand); + if (src_ptr_ty.zigTypeTag(sema.mod) != .Pointer) { + return sema.fail(block, src, "expected pointer operand, found '{}'", .{src_ptr_ty.fmt(sema.mod)}); + } + var src_ptr: Air.Inst.Ref = operand; + var src_ptr_ty_size: std.builtin.Type.Pointer.Size = .One; + // + // SIMPLIFY POINTER OPERAND: + // + // *[src_len]T From slice of array, correct by default. + var ptr_child_ty: Type = src_ptr_ty.childType(sema.mod); + var ptr_child_ty_tag: std.builtin.TypeId = ptr_child_ty.zigTypeTag(sema.mod); + const src_elem_ty: Type = if (ptr_child_ty_tag == .Pointer) blk: { + var ptr_child_child_ty: Type = ptr_child_ty.childType(sema.mod); + // *[]T From slice of slice: + // ;; ptr_child_ty = []T + // ;; ptr_size => Slice + // + // *[*]T From slice of pointer-to-many: + // ;; ptr_child_ty = [*]T + // ;; ptr_size => Many (C) + // + src_ptr_ty_size = ptr_child_ty.ptrSize(sema.mod); + src_ptr = try sema.analyzeLoad(block, src, src_ptr, operand_src); + if (src_ptr_ty_size != .One) break :blk ptr_child_child_ty; + // **T From slice of pointer-to-one: + // ;; src_ptr_ty => *T + // ;; elem_ty = T + src_ptr_ty = ptr_child_ty; + ptr_child_ty_tag = ptr_child_child_ty.zigTypeTag(sema.mod); + if (ptr_child_ty_tag != .Array) break :blk ptr_child_child_ty; + // **[src_len]T From slice of pointer-to-one array. + // ;; src_ptr_ty => *[src_len]T + // ;; ptr_child_ty => [src_len]T + // ;; elem_ty => T + ptr_child_ty = src_ptr_ty.childType(sema.mod); + break :blk ptr_child_ty.childType(sema.mod); + } else if (ptr_child_ty_tag == .Array) blk: { + break :blk ptr_child_ty.childType(sema.mod); + } else { + return sema.fail(block, src, "slice of non-array type '{}'", .{ptr_child_ty.fmt(sema.mod)}); + }; + const elem_ty: Type = if (dest_ty.isSlice(sema.mod)) dest_ty.childType(sema.mod) else src_elem_ty; + // [*]const T ;; Used to compute the start pointer by pointer arithmetic. + const many_ptr_ty: Type = try sema.mod.manyConstPtrType(elem_ty); + // *const T ;; Used to refer to the element at the sentinel index. + const elem_ptr_ty: Type = try sema.mod.singleConstPtrType(elem_ty); + // This property is used a lot later to avoid behaviour which is only + // intended for input pointers where the length is allowed known. + const src_ptr_explicit_len: bool = src_ptr_ty_size == .One or src_ptr_ty_size == .Slice; + // This is used to determine whether testing for length overflow by + // sentinel length extension is within contract. This is not marked + // for deletion because a special syntax for slice-to-sentinel would + // use the same logic. + const src_ptr_ty_is_allowzero: bool = src_ptr_ty.ptrInfo(sema.mod).flags.is_allowzero; + // Initial state of values and safety checks (4 bytes): + var sa: SliceAnalysis = .{}; + // The base pointer is not optional so `unknown` means it is undefined. + const src_ptr_val: Value = blk: { + if (try sema.resolveValue(src_ptr)) |val| { + sa.src_ptr = if (val.isUndef(sema.mod)) .unknown else .known; + break :blk val; + } + break :blk Value.undef; + }; + const src_sent_val: Value = blk: { + // This value is never usable by pointer sizes `C` and `Many`. + if (!src_ptr_explicit_len) { + break :blk Value.undef; + } + if (ptr_child_ty.sentinel(sema.mod)) |val| { + sa.src_sent = .known; + break :blk val; + } + break :blk Value.undef; + }; + // Try to extract any upper bound from the input pointer. + // * Use the type information `Array.len` if Array. + // * Use the value `ptr.len` if Slice. + // * Use the base/parent type and offset if comptime-known `Many` or `C`. + var src_len: Air.Inst.Ref = switch (src_ptr_ty_size) { + .One => if (ptr_child_ty_tag == .Array) + try sema.mod.intRef(Type.usize, ptr_child_ty.arrayLen(sema.mod)) + else + Air.Inst.Ref.one_usize, + .Slice => if (sa.src_ptr == .unknown) + Air.Inst.Ref.zero_usize + else + try sema.analyzeSliceLen(block, operand_src, src_ptr), + .C, .Many => blk: { + if (feature_prevent_inval_ptr and sa.src_ptr == .known) { + const elem_size: u64 = try sema.typeAbiSize(elem_ty); + if (elem_size == 0) { + if (try reinterpretLengthOfContainingDecl(sema, block, src, src_ptr_val, elem_ty)) |idx_int| { + break :blk try sema.mod.intRef(Type.usize, try sema.usizeCast(block, src, idx_int)); + } + } else { + if (try abiSizeOfContainingDecl(sema, block, src, src_ptr_val)) |memsz_int| { + break :blk try sema.mod.intRef(Type.usize, try sema.usizeCast(block, src, memsz_int / elem_size)); + } + } + } + break :blk .none; + }, + }; + // Update src_len using destination slice type (if any). + if (dest_ty.isSlice(sema.mod)) { + const from_size: u64 = try sema.typeAbiSize(src_elem_ty); + const to_size: u64 = try sema.typeAbiSize(elem_ty); + if (from_size < to_size) { + const div_rhs: Air.Inst.Ref = try sema.mod.intRef(Type.u8, to_size / from_size); + src_len = try sema.analyzeDivTrunc(block, src, src_len, div_rhs, operand_src, operand_src); + } else { + const mul_rhs: Air.Inst.Ref = try sema.mod.intRef(Type.u8, from_size / to_size); + src_len = try sema.analyzeArithmetic(block, .mul, src_len, mul_rhs, src, operand_src, operand_src, true); + } + } + // Attempt to resolve the pointer length. + const src_len_val: Value = blk: { + if (src_len != .none) { + sa.src_len = .variable; + + if (try sema.resolveDefinedValue(block, operand_src, src_len)) |val| { + sa.src_len = .known; + break :blk val; + } + } + break :blk Value.undef; + }; + // The start index is not optional, so `unknown` means that start is + // equivalent to `Value.zero_usize`. + const dest_start_val: Value = blk: { + if (try sema.resolveDefinedValue(block, dest_start_src, dest_start)) |val| { + sa.dest_start = if (try sema.compareAll(val, .eq, Value.zero_usize, Type.usize)) .unknown else .known; + break :blk val; + } + break :blk Value.undef; + }; + // Coerce end operand. + const dest_end: Air.Inst.Ref = blk: { + if (uncasted_dest_end_opt != .none) { + break :blk try sema.coerce(block, Type.usize, uncasted_dest_end_opt, dest_end_src); + } + break :blk .none; + }; + // Attempt to resolve the value of the end index. + const dest_end_val: Value = blk: { + if (dest_end != .none) { + sa.dest_end = .variable; + if (try sema.resolveDefinedValue(block, dest_end_src, dest_end)) |val| { + sa.dest_end = .known; + break :blk val; + } + } + break :blk Value.undef; + }; + // Deduce the length of the destination slice and attempt to resolve the + // result (with values preferred in this order): + // + // * Use 0 if `src_ptr` is known to be `undefined`. + // * Use `dest_len` if provided. + // * Use `dest_end - dest_start` if `dest_end` is provided (or simply `dest_end` if `dest_start` is known to be 0). + // * Use `src_len - dest_start` if `src_len` is provided (or simply `src_len` if `dest_start` is known to be 0). + // * Destination length is undefined. + // + // (`analyzeArithmetic` has the same optimisation for `zero_*` inputs) + // (`subwrap` is used below to avoid unclear compile errors from other functions) + // + const dest_len: Air.Inst.Ref = blk: { + if (uncasted_dest_len_opt != .none) { + break :blk try sema.coerce(block, Type.usize, uncasted_dest_len_opt, dest_end_src); + } + if (uncasted_dest_end_opt != .none) { + if (sa.dest_start != .unknown) { + break :blk try sema.analyzeArithmetic(block, .subwrap, dest_end, dest_start, src, dest_end_src, dest_start_src, false); + } + break :blk dest_end; + } + if (src_len != .none) { + if (sa.dest_start != .unknown) { + break :blk try sema.analyzeArithmetic(block, .subwrap, src_len, dest_start, src, operand_src, dest_start_src, false); + } + break :blk src_len; + } + break :blk .none; + }; + // Attempt to resolve the value of the destination length. + const dest_len_val: Value = blk: { + if (dest_len != .none) { + sa.dest_len = .variable; + if (try sema.resolveDefinedValue(block, src, dest_len)) |val| { + sa.dest_len = .known; + break :blk val; + } + } + break :blk Value.undef; + }; + // Attempt to resolve the value of the destination sentinel. + const dest_sent_val: Value = blk: { + if (dest_sent_opt != .none) { + if (!elem_ty.allowsSentinel(sema.mod)) { + return sema.fail(block, src, "sentinel not allowed for slice of non-scalar type '{}'", .{ + elem_ty.fmt(sema.mod), + }); + } + sa.dest_sent = .known; + const dest_sent: Air.Inst.Ref = try sema.coerce(block, elem_ty, dest_sent_opt, dest_sent_src); + if (try sema.resolveDefinedValue(block, dest_sent_src, dest_sent)) |val| { + break :blk val; + } + return sema.fail(block, dest_sent_src, "destination sentinel must be comptime-known", .{}); + } + break :blk Value.undef; + }; + // Variants such as ptr[0..] and ptr[0..][0..1] are allowed for *T. + if (src_ptr_ty_size == .One and ptr_child_ty_tag != .Array) { + if (sa.dest_start == .variable) { + return sema.fail(block, dest_start_src, "start index of slice of pointer-to-one must be comptime-known", .{}); + } + if (sa.dest_end == .variable) { + return sema.fail(block, dest_end_src, "end index of slice of pointer-to-one must be comptime-known", .{}); + } + } + // ATTENTION: Remove with `feature_allow_limited_slice_of_undefined`. + // Clarify behaviour of slices of constant undefined + // pointers. This is far too much logic to enable a foot-gun. + if (sa.src_ptr == .unknown) { + if (!feature_allow_limited_slice_of_undefined) { + return sema.fail(block, src, "slice of undefined pointer causes undefined behaviour", .{}); + } + if (sa.dest_len == .known) { + if (try sema.compareAll(dest_len_val, .neq, Value.zero_comptime_int, Type.comptime_int)) { + return sema.fail(block, src, "non-zero length slice of undefined pointer", .{}); + } + } else { + return sema.fail(block, src, "slice of undefined pointer with runtime length causes undefined behaviour", .{}); + } + if (sa.dest_sent == .known) { + return sema.fail(block, src, "sentinel not allowed for slice of undefined pointer", .{}); + } + } + // + // COMPUTE NEW POINTER `.ptr` + // + const new_ptr: Air.Inst.Ref = if (dest_ty.isSlice(sema.mod)) blk: { + const dest_manyptr_ty: Type = dest_ty.slicePtrFieldType(sema.mod); + break :blk try sema.ptrCastFull(block, flags, src, src_ptr, operand_src, dest_manyptr_ty, "@ptrCast"); + } else switch (src_ptr_ty_size) { + .Many, .C => src_ptr, + .Slice => try sema.analyzeSlicePtr(block, operand_src, src_ptr, sema.typeOf(src_ptr)), + .One => blk: { + var ptr_ty_key: InternPool.Key.PtrType = sema.mod.intern_pool.indexToKey(Type.toIntern(src_ptr_ty)).ptr_type; + ptr_ty_key.child = Type.toIntern(elem_ty); + ptr_ty_key.flags.size = .Many; + break :blk try sema.coerceCompatiblePtrs(block, try sema.ptrType(ptr_ty_key), src_ptr, operand_src); + }, + }; + const dest_ptr: Air.Inst.Ref = blk: { + if (sa.dest_start != .unknown) { + break :blk try sema.analyzePtrArithmetic(block, src, new_ptr, dest_start, .ptr_add, operand_src, dest_start_src); + } + break :blk new_ptr; + }; + // Attempt to resolve the value of the destination pointer. The return + // pointer is not optional, so the `unknown` state is for the special + // case @as([*]T, undefined). + const dest_ptr_val: Value = blk: { + if (try sema.resolveValue(dest_ptr)) |val| { + sa.dest_ptr = if (val.isUndef(sema.mod)) .unknown else .known; + break :blk val; + } + break :blk Value.undef; + }; + // + // SAFETY CHECKS: + // + // Determine bounds checks: + if (feature_allow_limited_slice_of_undefined and sa.src_ptr == .unknown) { + // ATTENTION: Remove this (no-op) branch with `feature_allow_limited_slice_of_undefined` + // Skip bounds checks if source pointer is known to be + // undefined. + // + // They are not necessary because we refuse any user-defined + // bounds. The length will be zero if the result is allowed + // to return. + } else { + sa.start_le_end = sa.dest_start.min(sa.dest_end); + sa.start_le_len = sa.dest_start.min(sa.src_len); + sa.end_le_len = sa.dest_end.min(sa.src_len); + } + // Optimise `slice_length` and `slice_end` to only check `start_le_len` + // at compile time. It is impossible for `dest_end` to be in bounds if + // `dest_start` is out of bounds. For `slice_length` this is an innate + // property of the syntax. For `slice_end`, this is guaranteed by + // `start_le_end`. + // + // A compile time check is desirable because `dest_len` might be + // runtime-known, meaning `dest_end` is also runtime-known. + if (uncasted_dest_end_opt != .none and sa.start_le_len == .variable) { + sa.start_le_len = .unknown; + } + // This should never happen, but there is no harm leaving the compile-time + // check active while testing. + if (kind == .slice_length and sa.start_le_end == .variable) { + sa.start_le_end = .unknown; + } + // Determine nullptr check: + if (src_ptr_ty_size == .C) { + sa.ptr_ne_null = sa.src_ptr; + } - return sema.analyzeSlice(block, src, array_ptr, start, len, sentinel, sentinel_src, ptr_src, start_src, end_src, true); + // Determine sentinel check: + if (uncasted_dest_end_opt != .none) { + sa.eq_sentinel = sa.src_ptr.min(sa.dest_end).min(sa.dest_sent); + } else if (uncasted_dest_len_opt != .none) { + sa.eq_sentinel = sa.dest_ptr.min(sa.dest_len).min(sa.dest_sent); + } else if (src_ptr_explicit_len) { + if (sa.dest_sent == .known and sa.src_sent == .unknown) { + return sema.fail(block, dest_sent_src, "sentinel index always out of bounds", .{}); + } + if (sa.dest_sent == .known) { + sa.eq_sentinel = sa.src_ptr.min(sa.src_len); + } + } + // + // OTHER VALUES: + // + // Attempt to resolve a pointer to the destination sentinel element: + const actual_sent_ptr_val: Value = blk: { + if (sa.eq_sentinel == .known) { + var idx_val: Value = src_len_val; + var ptr_inst: Air.Inst.Ref = new_ptr; + if (uncasted_dest_end_opt != .none) { + idx_val = dest_end_val; + } + if (uncasted_dest_len_opt != .none and sa.dest_len == .known) { + ptr_inst = dest_ptr; + idx_val = dest_len_val; + } + if (try sema.resolveValue(ptr_inst)) |ptr_val| { + const many_ptr_val: Value = try sema.mod.getCoerced(ptr_val, many_ptr_ty); + const idx: usize = try sema.usizeCast(block, src, idx_val.toUnsignedInt(sema.mod)); + break :blk try many_ptr_val.ptrElem(idx, sema); + } + } + break :blk Value.undef; + }; + // ATTENTION: Remove `feature_allow_slice_to_sentinel`. + // Compute sentinel-extended source pointer length. + const src_len2: Air.Inst.Ref = blk: { + // `slice_start` preserves the source sentinel for all source + // pointer sizes with an explicit length. The length can never be + // extended. + if (kind == .slice_start and src_ptr_explicit_len) { + break :blk src_len; + } + if (feature_allow_slice_to_sentinel and + sa.src_sent == .known and + sa.dest_sent == .unknown) + { + break :blk try sema.analyzeArithmetic(block, .add, src_len, .one, src, operand_src, dest_sent_src, src_ptr_ty_is_allowzero); + } + break :blk src_len; + }; + // ATTENTION: Remove with `feature_allow_slice_to_sentinel`. + // Attempt to resolve sentinel-extended source pointer length. + const src_len2_val: Value = blk: { + if (src_len2 != .none) { + if (try sema.resolveDefinedValue(block, operand_src, src_len2)) |val| { + break :blk val; + } + } + break :blk Value.undef; + }; + // + // COMPILE-TIME SAFETY CHECKS: + // + // Execute comptime bounds checks: + if (sa.end_le_len == .known) { + if (sa.dest_sent == .known and sa.src_sent == .unknown and + !try sema.compareScalar(dest_end_val, .lt, src_len2_val, Type.usize)) + { + if (try sema.compareScalar(dest_end_val, .eq, src_len2_val, Type.usize)) { + if (!src_ptr_explicit_len) { + return sema.fail(block, dest_end_src, "slice sentinel out of bounds of reinterpreted memory: end {}(+1), length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } else { + return sema.fail(block, dest_end_src, "slice sentinel out of bounds: end {}(+1), length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } else { + if (!src_ptr_explicit_len) { + return sema.fail(block, dest_end_src, "slice end out of bounds of reinterpreted memory: end {}(+1), length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } else { + return sema.fail(block, dest_end_src, "slice end out of bounds: end {}(+1), length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } + } else if (!try sema.compareScalar(dest_end_val, .lte, src_len2_val, Type.usize)) { + if (!src_ptr_explicit_len) { + return sema.fail(block, dest_end_src, "slice end out of bounds of reinterpreted memory: end {}, length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } else { + return sema.fail(block, dest_end_src, "slice end out of bounds: end {}, length {}", .{ + dest_end_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } + } + if (sa.start_le_end == .known) { + if (!try sema.compareScalar(dest_start_val, .lte, dest_end_val, Type.usize)) { + return sema.fail(block, dest_start_src, "bounds out of order: start {}, end {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + dest_end_val.fmtValue(sema.mod, sema), + }); + } + } + if (sa.start_le_len == .known) { + if (sa.dest_sent == .known and sa.src_sent == .unknown and + try sema.compareScalar(dest_start_val, .eq, src_len2_val, Type.usize)) + { + if (!src_ptr_explicit_len) { + return sema.fail(block, dest_start_src, "slice sentinel always out of bounds of reinterpreted memory: start {}, length {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } else { + return sema.fail(block, dest_start_src, "slice sentinel always out of bounds: start {}, length {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } else if (!try sema.compareScalar(dest_start_val, .lte, src_len2_val, Type.usize)) { + if (!src_ptr_explicit_len) { + return sema.fail(block, dest_start_src, "slice start out of bounds of reinterpreted memory: start {}, length {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } else { + return sema.fail(block, dest_start_src, "slice start out of bounds: start {}, length {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } + } + // Execute comptime nullptr check: + if (sa.ptr_ne_null == .known) { + if (src_ptr_val.isNull(sema.mod)) { + return sema.fail(block, operand_src, "slice of null pointer", .{}); + } + } + // Attempt comptime sentinel check else fallback to runtime check: + if (sa.eq_sentinel == .known) { + if (try sema.pointerDeref(block, src, actual_sent_ptr_val, elem_ptr_ty)) |actual_sent_val| { + if (!dest_sent_val.eql(actual_sent_val, elem_ty, sema.mod)) { + return sema.fail(block, dest_sent_src, "mismatched sentinel: expected {}, found {}", .{ + dest_sent_val.fmtValue(sema.mod, sema), + actual_sent_val.fmtValue(sema.mod, sema), + }); + } + } else { + sa.eq_sentinel = .variable; + } + } + // TODO: Removing `slice_start` (with sentinel) would make this unreachable. + if (feature_prevent_impossible_sent and !src_ptr_explicit_len and + sa.dest_start == .known and + sa.dest_sent == .known and + sa.src_len == .known) + { + if (try sema.compareScalar(dest_start_val, .eq, src_len2_val, Type.usize)) { + return sema.fail(block, dest_sent_src, "sentinel out of bounds of reinterpreted memory: start {}(+1), length {}", .{ + dest_start_val.fmtValue(sema.mod, sema), + src_len2_val.fmtValue(sema.mod, sema), + }); + } + } + if (sa.src_ptr == .variable) try sema.requireRuntimeBlock(block, src, operand_src); + if (sa.dest_start == .variable) try sema.requireRuntimeBlock(block, src, dest_start_src); + if (sa.dest_end == .variable or + sa.dest_len == .variable) try sema.requireRuntimeBlock(block, src, dest_end_src); + if (feature_prevent_inval_ptr and src_ptr_explicit_len) { + // TODO: Remove the false branch if `feature_prevent_inval_ptr` is + // declined. The purpose is to disable all runtime safety + // checks for slices without explicit lengths, as this would + // create an inconsistent behaviour for constant + // pointers-to-many. + } else { + if (sa.end_le_len == .variable) sa.end_le_len = .unknown; + if (sa.start_le_len == .variable) sa.start_le_len = .unknown; + if (sa.start_le_end == .variable) sa.start_le_end = .unknown; + } + // + // RUNTIME SAFETY CHECKS: + // + if (!block.is_comptime and block.wantSafety()) { + // Execute bounds checks: + const cmp_op: Air.Inst.Tag = if (sa.dest_sent == .known and sa.src_sent == .unknown) .cmp_lt else .cmp_lte; + if (sa.start_le_len == .variable) { + try RuntimeSafety.checkAccessOutOfOrder(sema, block, src, dest_start, src_len2); + } + if (sa.start_le_end == .variable and sa.end_le_len == .variable) { + try RuntimeSafety.checkAccessOutOfOrderExtra(sema, block, src, dest_start, dest_end, src_len2, cmp_op); + } else if (sa.start_le_end == .variable) { + try RuntimeSafety.checkAccessOutOfOrder(sema, block, src, dest_start, dest_end); + } else if (sa.end_le_len == .variable) { + try RuntimeSafety.checkAccessOutOfBounds(sema, block, src, dest_end, src_len2, cmp_op); + } + // Execute nullptr check: + if (sa.ptr_ne_null == .variable) { + const ok: Air.Inst.Ref = try sema.analyzeIsNull(block, operand_src, src_ptr, true); + try RuntimeSafety.checkAccessNullValue(sema, block, src, ok); + } + // Execute sentinel check: + if (sa.eq_sentinel == .variable) { + const casted_dest_ptr: Air.Inst.Ref = try sema.bitCast(block, many_ptr_ty, dest_ptr, src, operand_src); + const actual_sent_ptr: Air.Inst.Ref = try sema.analyzePtrArithmetic(block, src, casted_dest_ptr, dest_len, .ptr_add, operand_src, dest_end_src); + if (elem_ty.ip_index == Type.u8.ip_index and dest_sent_val.eql(Value.zero_u8, Type.u8, sema.mod)) { + try RuntimeSafety.checkMismatchedNullTerminator(sema, block, src, elem_ty, actual_sent_ptr); + } else { + const dest_sent: Air.Inst.Ref = Air.internedToRef(Value.toIntern(dest_sent_val)); + try RuntimeSafety.checkMismatchedSentinel(sema, block, src, elem_ty, dest_sent, actual_sent_ptr); + } + } + } + // + // TYPE INFORMATION: + // + // Deciding whether the return type is allowed to assert a sentinel value: + const dest_sent_ip: InternPool.Index = blk: { + if (sa.dest_sent == .known) { + break :blk Value.toIntern(dest_sent_val); + } + if (kind == .slice_start) { + if (sa.src_sent == .known) { + sa.dest_sent = .known; + break :blk Value.toIntern(src_sent_val); + } + } else if (sa.src_sent == .known and + sa.src_len.min(sa.dest_end) == .known and + try sema.compareScalar(src_len_val, .eq, dest_end_val, Type.usize)) + { + sa.dest_sent = .known; + break :blk Value.toIntern(src_sent_val); + } + break :blk .none; + }; + const dest_ptr_ty: Type = sema.typeOf(dest_ptr); + const dest_ptr_ty_info: InternPool.Key.PtrType = dest_ptr_ty.ptrInfo(sema.mod); + const dest_ptr_ty_is_allowzero: bool = dest_ptr_ty_info.flags.is_allowzero and src_ptr_ty_size != .C; + // TODO: Tidy up once `feature_prevent_inval_ptr` is confirmed. This + // behaviour should emerge earlier. + // Never attempt to use a derived length to define the destination + // type for pointer sizes Many and C for `slice_start` and + // `slice_sentinel` (start). + const dest_ptr_ty_omit_len: bool = !src_ptr_explicit_len and uncasted_dest_end_opt == .none; + const dest_ptr_ty_want_sent: bool = src_ptr_ty_size != .C or sa.dest_sent == .known; + // Factors determining pointer size: + // * The destination length is known at compile time + // => pointer-to-one Array + // + // * The source pointer size is C and the operation is `slice_sentinel` (start) + // => pointer-to-many with sentinel + // + const dest_ptr_size: std.builtin.Type.Pointer.Size = blk: { + const size_before_sent: std.builtin.Type.Pointer.Size = if (dest_ptr_ty_omit_len) + src_ptr_ty_size + else switch (sa.dest_len) { + .known => .One, + .variable => .Slice, + .unknown => src_ptr_ty_size, + }; + if (dest_ptr_ty_want_sent and + size_before_sent == .C) + { + break :blk .Many; + } else { + break :blk size_before_sent; + } + }; + // + // RETURN TYPE: + // + const dest_ptr_flags: InternPool.Key.PtrType.Flags = .{ + .size = dest_ptr_size, + .alignment = dest_ptr_ty_info.flags.alignment, + .is_const = dest_ptr_ty_info.flags.is_const, + .is_volatile = dest_ptr_ty_info.flags.is_volatile, + .is_allowzero = dest_ptr_ty_is_allowzero, + .address_space = dest_ptr_ty_info.flags.address_space, + }; + const return_ty: Type = switch (dest_ptr_size) { + .One => try sema.ptrType(.{ + .child = Type.toIntern(try sema.mod.arrayType(.{ + .child = Type.toIntern(elem_ty), + .len = (try dest_len_val.getUnsignedIntAdvanced(sema.mod, sema)).?, + .sentinel = dest_sent_ip, + })), + .flags = dest_ptr_flags, + }), + .Slice, .Many, .C => try sema.ptrType(.{ + .child = Type.toIntern(elem_ty), + .sentinel = dest_sent_ip, + .flags = dest_ptr_flags, + }), + }; + // + // RESULT: + // + if (dest_ptr_size != .Slice) { + // Returning a new constant pointer: + if (sa.dest_ptr == .known) { + // const interned_val: Value = Value.fromInterned((try dest_ptr_val.intern(dest_ptr_ty, sema.mod))); + const casted_val: Value = try sema.mod.getCoerced(dest_ptr_val, return_ty); + return Air.internedToRef(Value.toIntern(casted_val)); + } + // Returning a regular pointer: + return block.addBitCast(return_ty, dest_ptr); + } + // Creating and returning a slice: + return block.addInst(.{ .tag = .slice, .data = .{ .ty_pl = .{ + .ty = Air.internedToRef(Type.toIntern(return_ty)), + .payload = try sema.addExtra(Air.Bin{ .lhs = dest_ptr, .rhs = dest_len }), + } } }); } /// Holds common data used when analyzing or resolving switch prong bodies, @@ -12452,12 +13169,13 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index, operand_is_r if (err_set and try sema.maybeErrorUnwrap(block, special.body, operand, operand_src, false)) { return .unreachable_value; } - if (mod.backendSupportsFeature(.is_named_enum_value) and block.wantSafety() and operand_ty.zigTypeTag(mod) == .Enum and + if (mod.backendSupportsFeature(.is_named_enum_value) and + block.wantSafety() and operand_ty.zigTypeTag(mod) == .Enum and (!operand_ty.isNonexhaustiveEnum(mod) or union_originally)) { try sema.zirDbgStmt(block, cond_dbg_node_index); const ok = try block.addUnOp(.is_named_enum_value, operand); - try sema.addSafetyCheck(block, src, ok, .corrupt_switch); + try RuntimeSafety.checkCastToEnumFromInvalid(sema, block, src, operand_ty, operand, ok); } return spa.resolveProngComptime( @@ -13082,7 +13800,7 @@ fn analyzeSwitchRuntimeBlock( { try sema.zirDbgStmt(&case_block, cond_dbg_node_index); const ok = try case_block.addUnOp(.is_named_enum_value, operand); - try sema.addSafetyCheck(&case_block, src, ok, .corrupt_switch); + try RuntimeSafety.checkCastToEnumFromInvalid(sema, &case_block, src, operand_ty, operand, ok); } const analyze_body = if (union_originally and !special.is_inline) @@ -13114,7 +13832,7 @@ fn analyzeSwitchRuntimeBlock( // that it is unreachable. if (case_block.wantSafety()) { try sema.zirDbgStmt(&case_block, cond_dbg_node_index); - try sema.safetyPanic(&case_block, src, .corrupt_switch); + try RuntimeSafety.panicReachedUnreachable(sema, &case_block, src, .corrupt_switch); } else { _ = try case_block.addNoOp(.unreach); } @@ -13796,25 +14514,15 @@ fn maybeErrorUnwrap( .as_node => try sema.zirAsNode(block, inst), .field_val => try sema.zirFieldVal(block, inst), .@"unreachable" => { - if (!mod.comp.formatted_panics) { - try sema.safetyPanic(block, operand_src, .unwrap_error); - return true; - } + try RuntimeSafety.panicUnwrappedError(sema, block, operand_src, operand); - const panic_fn = try sema.getBuiltin("panicUnwrapError"); - const err_return_trace = try sema.getErrorReturnTrace(block); - const args: [2]Air.Inst.Ref = .{ err_return_trace, operand }; - try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); return true; }, .panic => { const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; const msg_inst = try sema.resolveInst(inst_data.operand); + try RuntimeSafety.panicWithMsg(sema, block, operand_src, msg_inst, .@"safety check"); - const panic_fn = try sema.getBuiltin("panic"); - const err_return_trace = try sema.getErrorReturnTrace(block); - const args: [3]Air.Inst.Ref = .{ msg_inst, err_return_trace, .null_value }; - try sema.callBuiltin(block, operand_src, panic_fn, .auto, &args, .@"safety check"); return true; }, else => unreachable, @@ -14156,7 +14864,7 @@ fn zirShl( const bit_count_inst = Air.internedToRef(bit_count_val.toIntern()); break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst); }; - try sema.addSafetyCheck(block, src, ok, .shift_rhs_too_big); + try RuntimeSafety.checkShiftAmountOverflow(sema, block, src, lhs_ty, rhs, ok); } if (air_tag == .shl_exact) { @@ -14185,7 +14893,7 @@ fn zirShl( const zero_ov = Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern()); const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov); - try sema.addSafetyCheck(block, src, no_ov, .shl_overflow); + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, lhs_ty, lhs, new_rhs, no_ov, air_tag); return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty); } } @@ -14285,8 +14993,8 @@ fn zirShr( } try sema.requireRuntimeBlock(block, src, runtime_src); - const result = try block.addBinOp(air_tag, lhs, rhs); if (block.wantSafety()) { + const result: Air.Inst.Ref = try block.addBinOp(.shr, lhs, rhs); const bit_count = scalar_ty.intInfo(mod).bits; if (!std.math.isPowerOfTwo(bit_count)) { const bit_count_val = try mod.intValue(rhs_ty.scalarType(mod), bit_count); @@ -14305,7 +15013,7 @@ fn zirShr( const bit_count_inst = Air.internedToRef(bit_count_val.toIntern()); break :ok try block.addBinOp(.cmp_lt, rhs, bit_count_inst); }; - try sema.addSafetyCheck(block, src, ok, .shift_rhs_too_big); + try RuntimeSafety.checkShiftAmountOverflow(sema, block, src, lhs_ty, rhs, ok); } if (air_tag == .shr_exact) { @@ -14321,10 +15029,12 @@ fn zirShr( } }, }); } else try block.addBinOp(.cmp_eq, lhs, back); - try sema.addSafetyCheck(block, src, ok, .shr_overflow); + + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, lhs_ty, lhs, rhs, ok, air_tag); } + return result; } - return result; + return block.addBinOp(air_tag, lhs, rhs); } fn zirBitwise( @@ -15455,7 +16165,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai break :ok is_in_range; } }; - try sema.addSafetyCheck(block, src, ok, .exact_division_remainder); + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, resolved_type, casted_lhs, casted_rhs, ok, .div_exact); return result; } @@ -15572,19 +16282,19 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai return block.addBinOp(airTag(block, is_int, .div_floor, .div_floor_optimized), casted_lhs, casted_rhs); } -fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const mod = sema.mod; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; - const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node }; - const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node }; - const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node }; - const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; - const lhs = try sema.resolveInst(extra.lhs); - const rhs = try sema.resolveInst(extra.rhs); +fn analyzeDivTrunc( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + lhs: Air.Inst.Ref, + rhs: Air.Inst.Ref, + lhs_src: LazySrcLoc, + rhs_src: LazySrcLoc, +) CompileError!Air.Inst.Ref { const lhs_ty = sema.typeOf(lhs); const rhs_ty = sema.typeOf(rhs); - const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(mod); - const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(mod); + const lhs_zig_ty_tag = try lhs_ty.zigTypeTagOrPoison(sema.mod); + const rhs_zig_ty_tag = try rhs_ty.zigTypeTagOrPoison(sema.mod); try sema.checkVectorizableBinaryOperands(block, src, lhs_ty, rhs_ty, lhs_src, rhs_src); try sema.checkInvalidPtrArithmetic(block, src, lhs_ty); @@ -15596,9 +16306,9 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai 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(mod); - const rhs_scalar_ty = rhs_ty.scalarType(mod); - const scalar_tag = resolved_type.scalarType(mod).zigTypeTag(mod); + const lhs_scalar_ty = lhs_ty.scalarType(sema.mod); + const rhs_scalar_ty = rhs_ty.scalarType(sema.mod); + const scalar_tag = resolved_type.scalarType(sema.mod).zigTypeTag(sema.mod); const is_int = scalar_tag == .Int or scalar_tag == .ComptimeInt; @@ -15628,11 +16338,11 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // 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(mod)) { + if (!lhs_val.isUndef(sema.mod)) { if (try lhs_val.compareAllWithZeroAdvanced(.eq, sema)) { const scalar_zero = switch (scalar_tag) { - .ComptimeFloat, .Float => try mod.floatValue(resolved_type.scalarType(mod), 0.0), - .ComptimeInt, .Int => try mod.intValue(resolved_type.scalarType(mod), 0), + .ComptimeFloat, .Float => try sema.mod.floatValue(resolved_type.scalarType(sema.mod), 0.0), + .ComptimeInt, .Int => try sema.mod.intValue(resolved_type.scalarType(sema.mod), 0), else => unreachable, }; const zero_val = try sema.splat(resolved_type, scalar_zero); @@ -15641,7 +16351,7 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } } if (maybe_rhs_val) |rhs_val| { - if (rhs_val.isUndef(mod)) { + if (rhs_val.isUndef(sema.mod)) { return sema.failWithUseOfUndef(block, rhs_src); } if (!(try rhs_val.compareAllWithZeroAdvanced(.neq, sema))) { @@ -15649,28 +16359,28 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } } if (maybe_lhs_val) |lhs_val| { - if (lhs_val.isUndef(mod)) { - if (lhs_scalar_ty.isSignedInt(mod) and rhs_scalar_ty.isSignedInt(mod)) { + if (lhs_val.isUndef(sema.mod)) { + if (lhs_scalar_ty.isSignedInt(sema.mod) and rhs_scalar_ty.isSignedInt(sema.mod)) { if (maybe_rhs_val) |rhs_val| { - if (try sema.compareAll(rhs_val, .neq, try mod.intValue(resolved_type, -1), resolved_type)) { - return mod.undefRef(resolved_type); + if (try sema.compareAll(rhs_val, .neq, try sema.mod.intValue(resolved_type, -1), resolved_type)) { + return sema.mod.undefRef(resolved_type); } } return sema.failWithUseOfUndef(block, rhs_src); } - return mod.undefRef(resolved_type); + return sema.mod.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, mod); + const res = try lhs_val.intDiv(rhs_val, resolved_type, &overflow_idx, sema.arena, sema.mod); 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, mod)).toIntern()); + return Air.internedToRef((try lhs_val.floatDivTrunc(rhs_val, resolved_type, sema.arena, sema.mod)).toIntern()); } } else break :rs rhs_src; } else break :rs lhs_src; @@ -15686,6 +16396,18 @@ fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai return block.addBinOp(airTag(block, is_int, .div_trunc, .div_trunc_optimized), casted_lhs, casted_rhs); } +fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { + const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const src: LazySrcLoc = .{ .node_offset_bin_op = inst_data.src_node }; + const lhs_src: LazySrcLoc = .{ .node_offset_bin_lhs = inst_data.src_node }; + const rhs_src: LazySrcLoc = .{ .node_offset_bin_rhs = inst_data.src_node }; + const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; + const lhs = try sema.resolveInst(extra.lhs); + const rhs = try sema.resolveInst(extra.rhs); + + return sema.analyzeDivTrunc(block, src, lhs, rhs, lhs_src, rhs_src); +} + fn addDivIntOverflowSafety( sema: *Sema, block: *Block, @@ -15763,7 +16485,7 @@ fn addDivIntOverflowSafety( } assert(ok != .none); } - try sema.addSafetyCheck(block, src, ok, .integer_overflow); + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, resolved_type, casted_lhs, casted_rhs, ok, .div_trunc); } fn addDivByZeroSafety( @@ -15802,7 +16524,7 @@ fn addDivByZeroSafety( const zero = Air.internedToRef(scalar_zero.toIntern()); break :ok try block.addBinOp(if (is_int) .cmp_neq else .cmp_neq_optimized, casted_rhs, zero); }; - try sema.addSafetyCheck(block, src, ok, .divide_by_zero); + try RuntimeSafety.checkDivisionByZero(sema, block, src, ok); } fn airTag(block: *Block, is_int: bool, normal: Air.Inst.Tag, optimized: Air.Inst.Tag) Air.Inst.Tag { @@ -16474,7 +17196,8 @@ fn analyzeArithmetic( 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: { + + const runtime_src: LazySrcLoc, const air_tag: Air.Inst.Tag = rs: { switch (zir_tag) { .add, .add_unsafe => { // For integers:intAddSat @@ -16521,8 +17244,8 @@ fn analyzeArithmetic( } else { return Air.internedToRef((try Value.floatAdd(lhs_val, rhs_val, resolved_type, sema.arena, mod)).toIntern()); } - } else break :rs .{ rhs_src, air_tag, .add_safe }; - } else break :rs .{ lhs_src, air_tag, .add_safe }; + } else break :rs .{ rhs_src, air_tag }; + } else break :rs .{ lhs_src, air_tag }; }, .addwrap => { // Integers only; floats are checked above. @@ -16542,8 +17265,8 @@ fn analyzeArithmetic( } 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 }; + } else break :rs .{ lhs_src, .add_wrap }; + } else break :rs .{ rhs_src, .add_wrap }; }, .add_sat => { // Integers only; floats are checked above. @@ -16575,12 +17298,10 @@ fn analyzeArithmetic( } else break :rs .{ lhs_src, .add_sat, - .add_sat, }; } else break :rs .{ rhs_src, .add_sat, - .add_sat, }; }, .sub => { @@ -16623,8 +17344,8 @@ fn analyzeArithmetic( } else { return Air.internedToRef((try Value.floatSub(lhs_val, rhs_val, resolved_type, sema.arena, mod)).toIntern()); } - } else break :rs .{ rhs_src, air_tag, .sub_safe }; - } else break :rs .{ lhs_src, air_tag, .sub_safe }; + } else break :rs .{ rhs_src, air_tag }; + } else break :rs .{ lhs_src, air_tag }; }, .subwrap => { // Integers only; floats are checked above. @@ -16644,8 +17365,8 @@ fn analyzeArithmetic( } 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 }; + } else break :rs .{ rhs_src, .sub_wrap }; + } else break :rs .{ lhs_src, .sub_wrap }; }, .sub_sat => { // Integers only; floats are checked above. @@ -16670,8 +17391,8 @@ fn analyzeArithmetic( try lhs_val.intSubSat(rhs_val, resolved_type, sema.arena, mod); return Air.internedToRef(val.toIntern()); - } else break :rs .{ rhs_src, .sub_sat, .sub_sat }; - } else break :rs .{ lhs_src, .sub_sat, .sub_sat }; + } else break :rs .{ rhs_src, .sub_sat }; + } else break :rs .{ lhs_src, .sub_sat }; }, .mul => { // For integers: @@ -16765,8 +17486,8 @@ fn analyzeArithmetic( } else { return Air.internedToRef((try lhs_val.floatMul(rhs_val, resolved_type, sema.arena, mod)).toIntern()); } - } else break :rs .{ lhs_src, air_tag, .mul_safe }; - } else break :rs .{ rhs_src, air_tag, .mul_safe }; + } else break :rs .{ lhs_src, air_tag }; + } else break :rs .{ rhs_src, air_tag }; }, .mulwrap => { // Integers only; floats are handled above. @@ -16810,8 +17531,8 @@ fn analyzeArithmetic( return mod.undefRef(resolved_type); } return Air.internedToRef((try lhs_val.numberMulWrap(rhs_val, resolved_type, sema.arena, mod)).toIntern()); - } else break :rs .{ lhs_src, .mul_wrap, .mul_wrap }; - } else break :rs .{ rhs_src, .mul_wrap, .mul_wrap }; + } else break :rs .{ lhs_src, .mul_wrap }; + } else break :rs .{ rhs_src, .mul_wrap }; }, .mul_sat => { // Integers only; floats are checked above. @@ -16861,8 +17582,8 @@ fn analyzeArithmetic( try lhs_val.intMulSat(rhs_val, resolved_type, sema.arena, mod); return Air.internedToRef(val.toIntern()); - } else break :rs .{ lhs_src, .mul_sat, .mul_sat }; - } else break :rs .{ rhs_src, .mul_sat, .mul_sat }; + } else break :rs .{ lhs_src, .mul_sat }; + } else break :rs .{ rhs_src, .mul_sat }; }, else => unreachable, } @@ -16870,49 +17591,49 @@ fn analyzeArithmetic( try sema.requireRuntimeBlock(block, src, runtime_src); - if (block.wantSafety() and want_safety and scalar_tag == .Int) { - if (mod.backendSupportsFeature(.safety_checked_instructions)) { - if (air_tag != air_tag_safe) { - _ = try sema.preparePanicId(block, .integer_overflow); - } - return block.addBinOp(air_tag_safe, casted_lhs, casted_rhs); - } else { - const maybe_op_ov: ?Air.Inst.Tag = switch (air_tag) { - .add => .add_with_overflow, - .sub => .sub_with_overflow, - .mul => .mul_with_overflow, - else => null, - }; - if (maybe_op_ov) |op_ov_tag| { - const op_ov_tuple_ty = try sema.overflowArithmeticTupleType(resolved_type); - const op_ov = try block.addInst(.{ - .tag = op_ov_tag, - .data = .{ .ty_pl = .{ - .ty = Air.internedToRef(op_ov_tuple_ty.toIntern()), - .payload = try sema.addExtra(Air.Bin{ - .lhs = casted_lhs, - .rhs = casted_rhs, - }), - } }, - }); - const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty); - const any_ov_bit = if (resolved_type.zigTypeTag(mod) == .Vector) - try block.addInst(.{ - .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce, - .data = .{ .reduce = .{ - .operand = ov_bit, - .operation = .Or, - } }, - }) - else - ov_bit; - const zero_ov = Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern()); - const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov); - - try sema.addSafetyCheck(block, src, no_ov, .integer_overflow); - return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty); - } - } + if (block.wantSafety() and want_safety and scalar_tag == .Int) blk: { + if (mod.backendSupportsFeature(.safety_checked_instructions) and + sema.mod.safety.fn_cache[1] != .none) + { + return block.addBinOp(switch (air_tag) { + .add => .add_safe, + .sub => .sub_safe, + .mul => .mul_safe, + else => break :blk, + }, casted_lhs, casted_rhs); + } + const op_ov_tag: Air.Inst.Tag = switch (air_tag) { + .add => .add_with_overflow, + .sub => .sub_with_overflow, + .mul => .mul_with_overflow, + else => break :blk, + }; + const op_ov_tuple_ty = try sema.overflowArithmeticTupleType(resolved_type); + const op_ov = try block.addInst(.{ + .tag = op_ov_tag, + .data = .{ .ty_pl = .{ + .ty = Air.internedToRef(op_ov_tuple_ty.toIntern()), + .payload = try sema.addExtra(Air.Bin{ + .lhs = casted_lhs, + .rhs = casted_rhs, + }), + } }, + }); + const ov_bit = try sema.tupleFieldValByIndex(block, src, op_ov, 1, op_ov_tuple_ty); + const any_ov_bit = if (resolved_type.zigTypeTag(mod) == .Vector) + try block.addInst(.{ + .tag = if (block.float_mode == .optimized) .reduce_optimized else .reduce, + .data = .{ .reduce = .{ + .operand = ov_bit, + .operation = .Or, + } }, + }) + else + ov_bit; + const zero_ov = Air.internedToRef((try mod.intValue(Type.u1, 0)).toIntern()); + const no_ov = try block.addBinOp(.cmp_eq, any_ov_bit, zero_ov); + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, resolved_type, casted_lhs, casted_rhs, no_ov, air_tag); + return sema.tupleFieldValByIndex(block, src, op_ov, 0, op_ov_tuple_ty); } return block.addBinOp(air_tag, casted_lhs, casted_rhs); } @@ -19907,6 +20628,11 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const val = try sema.resolveConstDefinedValue(block, sentinel_src, coerced, .{ .needed_comptime_reason = "pointer sentinel value must be comptime-known", }); + if (!elem_ty.allowsSentinel(mod)) { + return sema.fail(block, sentinel_src, "sentinel not allowed for aggregate of non-scalar type '{}'", .{ + elem_ty.fmt(mod), + }); + } break :blk val.toIntern(); } else .none; @@ -21035,12 +21761,13 @@ fn getErrorReturnTrace(sema: *Sema, block: *Block) CompileError!Air.Inst.Ref { try sema.resolveTypeFields(stack_trace_ty); const ptr_stack_trace_ty = try mod.singleMutPtrType(stack_trace_ty); const opt_ptr_stack_trace_ty = try mod.optionalType(ptr_stack_trace_ty.toIntern()); - - if (sema.owner_func_index != .none and - ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn and - block.ownerModule().error_tracing) - { - return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty); + if (sema.mod.backendSupportsFeature(.error_return_trace)) { + if (sema.owner_func_index != .none and + ip.funcAnalysis(sema.owner_func_index).calls_or_awaits_errorable_fn and + block.ownerModule().error_tracing) + { + return block.addTy(.err_return_trace, opt_ptr_stack_trace_ty); + } } return Air.internedToRef((try mod.intern(.{ .opt = .{ .ty = opt_ptr_stack_trace_ty.toIntern(), @@ -21287,7 +22014,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air try sema.requireRuntimeBlock(block, src, operand_src); if (block.wantSafety() and sema.mod.backendSupportsFeature(.is_named_enum_value)) { const ok = try block.addUnOp(.is_named_enum_value, casted_operand); - try sema.addSafetyCheck(block, src, ok, .invalid_enum_value); + try RuntimeSafety.checkCastToEnumFromInvalid(sema, block, src, enum_ty, casted_operand, ok); } // In case the value is runtime-known, we have an AIR instruction for this instead // of trying to lower it in Sema because an optimization pass may result in the operand @@ -21443,6 +22170,11 @@ fn zirReify( if (ptr_size == .One or ptr_size == .C) { return sema.fail(block, src, "sentinels are only allowed on slices and unknown-length pointers", .{}); } + if (!elem_ty.allowsSentinel(mod)) { + return sema.fail(block, src, "sentinel not allowed for aggregate of non-scalar type '{}'", .{ + elem_ty.fmt(mod), + }); + } const sentinel_ptr_val = sentinel_val.optionalValue(mod).?; const ptr_ty = try mod.singleMutPtrType(elem_ty); const sent_val = (try sema.pointerDeref(block, src, sentinel_ptr_val, ptr_ty)).?; @@ -22576,7 +23308,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro if (!is_vector) { if (block.wantSafety()) { const ok = try block.addBinOp(if (block.float_mode == .optimized) .cmp_eq_optimized else .cmp_eq, operand, Air.internedToRef((try mod.floatValue(operand_ty, 0.0)).toIntern())); - try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds); + try RuntimeSafety.checkCastToIntFromInvalid(sema, block, src, dest_ty, operand_ty, operand, ok); } return Air.internedToRef((try mod.intValue(dest_ty, 0)).toIntern()); } @@ -22586,7 +23318,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro const idx_ref = try mod.intRef(Type.usize, i); const elem_ref = try block.addBinOp(.array_elem_val, operand, idx_ref); const ok = try block.addBinOp(if (block.float_mode == .optimized) .cmp_eq_optimized else .cmp_eq, elem_ref, Air.internedToRef((try mod.floatValue(operand_scalar_ty, 0.0)).toIntern())); - try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds); + try RuntimeSafety.checkCastToIntFromInvalid(sema, block, src, dest_ty, operand_scalar_ty, elem_ref, ok); } } return Air.internedToRef(try mod.intern(.{ .aggregate = .{ @@ -22602,7 +23334,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro const ok_pos = try block.addBinOp(if (block.float_mode == .optimized) .cmp_lt_optimized else .cmp_lt, diff, Air.internedToRef((try mod.floatValue(operand_ty, 1.0)).toIntern())); const ok_neg = try block.addBinOp(if (block.float_mode == .optimized) .cmp_gt_optimized else .cmp_gt, diff, Air.internedToRef((try mod.floatValue(operand_ty, -1.0)).toIntern())); const ok = try block.addBinOp(.bool_and, ok_pos, ok_neg); - try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds); + try RuntimeSafety.checkCastToIntFromInvalid(sema, block, src, dest_ty, operand_ty, operand, ok); } return result; } @@ -22618,7 +23350,7 @@ fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro const ok_pos = try block.addBinOp(if (block.float_mode == .optimized) .cmp_lt_optimized else .cmp_lt, diff, Air.internedToRef((try mod.floatValue(operand_scalar_ty, 1.0)).toIntern())); const ok_neg = try block.addBinOp(if (block.float_mode == .optimized) .cmp_gt_optimized else .cmp_gt, diff, Air.internedToRef((try mod.floatValue(operand_scalar_ty, -1.0)).toIntern())); const ok = try block.addBinOp(.bool_and, ok_pos, ok_neg); - try sema.addSafetyCheck(block, src, ok, .integer_part_out_of_bounds); + try RuntimeSafety.checkCastToIntFromInvalid(sema, block, src, dest_ty, operand_scalar_ty, old_elem, ok); } new_elem.* = result; } @@ -22728,14 +23460,14 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! if (block.wantSafety() and (try sema.typeHasRuntimeBits(elem_ty) or elem_ty.zigTypeTag(mod) == .Fn)) { if (!ptr_ty.isAllowzeroPtr(mod)) { const is_non_zero = try block.addBinOp(.cmp_neq, operand_coerced, .zero_usize); - try sema.addSafetyCheck(block, src, is_non_zero, .cast_to_null); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, ptr_ty, operand_coerced, is_non_zero); } if (ptr_align.compare(.gt, .@"1")) { const align_bytes_minus_1 = ptr_align.toByteUnits().? - 1; const align_minus_1 = Air.internedToRef((try mod.intValue(Type.usize, align_bytes_minus_1)).toIntern()); const remainder = try block.addBinOp(.bit_and, operand_coerced, align_minus_1); const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize); - try sema.addSafetyCheck(block, src, is_aligned, .incorrect_alignment); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, ptr_ty, operand_coerced, is_aligned); } } return block.addBitCast(dest_ty, operand_coerced); @@ -22748,14 +23480,14 @@ fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const elem_coerced = try block.addBinOp(.array_elem_val, operand_coerced, idx_ref); if (!ptr_ty.isAllowzeroPtr(mod)) { const is_non_zero = try block.addBinOp(.cmp_neq, elem_coerced, .zero_usize); - try sema.addSafetyCheck(block, src, is_non_zero, .cast_to_null); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, ptr_ty, elem_coerced, is_non_zero); } if (ptr_align.compare(.gt, .@"1")) { const align_bytes_minus_1 = ptr_align.toByteUnits().? - 1; const align_minus_1 = Air.internedToRef((try mod.intValue(Type.usize, align_bytes_minus_1)).toIntern()); const remainder = try block.addBinOp(.bit_and, elem_coerced, align_minus_1); const is_aligned = try block.addBinOp(.cmp_eq, remainder, .zero_usize); - try sema.addSafetyCheck(block, src, is_aligned, .incorrect_alignment); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, ptr_ty, elem_coerced, is_aligned); } } } @@ -22905,21 +23637,20 @@ fn zirErrorCast(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData const err_code = try sema.analyzeErrUnionCode(block, operand_src, operand); const err_int = try block.addBitCast(err_int_ty, err_code); const zero_err = try mod.intRef(try mod.errorIntType(), 0); - const is_zero = try block.addBinOp(.cmp_eq, err_int, zero_err); if (disjoint) { // Error must be zero. - try sema.addSafetyCheck(block, src, is_zero, .invalid_error_code); + try RuntimeSafety.checkCastToErrorFromInvalid(sema, block, src, dest_ty, operand_ty, err_code, is_zero); } else { // Error must be in destination set or zero. const has_value = try block.addTyOp(.error_set_has_value, dest_ty, err_code); const ok = try block.addBinOp(.bool_or, has_value, is_zero); - try sema.addSafetyCheck(block, src, ok, .invalid_error_code); + try RuntimeSafety.checkCastToErrorFromInvalid(sema, block, src, dest_ty, operand_ty, err_code, ok); } } else { const err_int_inst = try block.addBitCast(err_int_ty, operand); const ok = try block.addTyOp(.error_set_has_value, dest_ty, err_int_inst); - try sema.addSafetyCheck(block, src, ok, .invalid_error_code); + try RuntimeSafety.checkCastToErrorFromInvalid(sema, block, src, dest_ty, operand_ty, operand, ok); } } return block.addBitCast(base_dest_ty, operand); @@ -23004,7 +23735,30 @@ fn ptrCastFull( }; const dest_elem_size = Type.fromInterned(dest_info.child).abiSize(mod); if (src_elem_size != dest_elem_size) { - return sema.fail(block, src, "TODO: implement {s} between slices changing the length", .{operation}); + if (!flags.ptr_cast) { + return sema.failWithOwnedErrorMsg(block, msg: { + const msg = try sema.errMsg(block, src, "slice element type '{}' cannot coerce into element type '{}'", .{ + Type.fromInterned(src_info.child).fmt(sema.mod), + Type.fromInterned(dest_info.child).fmt(sema.mod), + }); + errdefer msg.destroy(sema.gpa); + try sema.errNote(block, src, msg, "use @ptrCast to cast slice element type", .{}); + break :msg msg; + }); + } + if (dest_ty.sentinel(sema.mod) != null) { + return sema.fail(block, src, "cannot cast to slice type '{}'; sentinel not allowed", .{dest_ty.fmt(sema.mod)}); + } + if (src_elem_size != 0 and dest_elem_size != 0) { + // Prepare pointer (if necessary) for slicing. + const src_ptr: Air.Inst.Ref = if (src_info.flags.size == .One) + operand + else + try sema.analyzeRef(block, operand_src, operand); + // Forward to `slice_start` operation requesting a new type. + // The manyptr will be sent back, but the slice logic will handle the length scaling. + return sema.analyzeSlice2(block, flags, src, src_ptr, dest_ty, Air.Inst.Ref.zero_usize, .none, .none, .none, operand_src, operand_src, operand_src, .unneeded, .slice_start); + } } } @@ -23291,7 +24045,7 @@ fn ptrCastFull( const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize); break :ok try block.addBinOp(.bool_or, len_zero, is_non_zero); } else is_non_zero; - try sema.addSafetyCheck(block, src, ok, .cast_to_null); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, dest_ptr_ty, ptr_int, ok); } if (block.wantSafety() and @@ -23308,7 +24062,7 @@ fn ptrCastFull( const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize); break :ok try block.addBinOp(.bool_or, len_zero, is_aligned); } else is_aligned; - try sema.addSafetyCheck(block, src, ok, .incorrect_alignment); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, src, dest_ptr_ty, ptr_int, ok); } // If we're going from an array pointer to a slice, this will only be the pointer part! @@ -25586,7 +26340,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void if (block.wantSafety()) { const ok = try block.addBinOp(.cmp_eq, dest_len, src_len); - try sema.addSafetyCheck(block, src, ok, .memcpy_len_mismatch); + try RuntimeSafety.checkMismatchedMemcpyArgumentLengths(sema, block, src, dest_len, src_len, ok); } } else if (dest_len != .none) { if (try sema.resolveDefinedValue(block, dest_src, dest_len)) |dest_len_val| { @@ -25679,7 +26433,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void } else if (dest_len == .none and len_val == null) { // Change the dest to a slice, since its type must have the length. const dest_ptr_ptr = try sema.analyzeRef(block, dest_src, new_dest_ptr); - new_dest_ptr = try sema.analyzeSlice(block, dest_src, dest_ptr_ptr, .zero, src_len, .none, .unneeded, dest_src, dest_src, dest_src, false); + new_dest_ptr = try analyzeSlice2(sema, block, .{}, dest_src, dest_ptr_ptr, Type.void, .zero, src_len, .none, .none, dest_src, dest_src, dest_src, .unneeded, .slice_end); const new_src_ptr_ty = sema.typeOf(new_src_ptr); if (new_src_ptr_ty.isSlice(mod)) { new_src_ptr = try sema.analyzeSlicePtr(block, src_src, new_src_ptr, new_src_ptr_ty); @@ -25728,7 +26482,7 @@ fn zirMemcpy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const ok1 = try block.addBinOp(.cmp_gte, raw_dest_ptr, src_plus_len); const ok2 = try block.addBinOp(.cmp_gte, new_src_ptr, dest_plus_len); const ok = try block.addBinOp(.bool_or, ok1, ok2); - try sema.addSafetyCheck(block, src, ok, .memcpy_alias); + try RuntimeSafety.checkAliasingMemcpyArguments(sema, block, src, raw_dest_ptr, dest_plus_len, raw_src_ptr, src_plus_len, ok); } _ = try block.addInst(.{ @@ -26969,40 +27723,6 @@ fn explainWhyTypeIsNotPacked( } } -fn prepareSimplePanic(sema: *Sema, block: *Block) !void { - const mod = sema.mod; - - if (mod.panic_func_index == .none) { - const decl_index = (try sema.getBuiltinDecl(block, "panic")); - // decl_index may be an alias; we must find the decl that actually - // owns the function. - try sema.ensureDeclAnalyzed(decl_index); - const fn_val = try mod.declPtr(decl_index).valueOrFail(); - try sema.declareDependency(.{ .decl_val = decl_index }); - assert(fn_val.typeOf(mod).zigTypeTag(mod) == .Fn); - assert(try sema.fnHasRuntimeBits(fn_val.typeOf(mod))); - try mod.ensureFuncBodyAnalysisQueued(fn_val.toIntern()); - mod.panic_func_index = fn_val.toIntern(); - } - - if (mod.null_stack_trace == .none) { - const stack_trace_ty = try sema.getBuiltinType("StackTrace"); - try sema.resolveTypeFields(stack_trace_ty); - const target = mod.getTarget(); - const ptr_stack_trace_ty = try sema.ptrType(.{ - .child = stack_trace_ty.toIntern(), - .flags = .{ - .address_space = target_util.defaultAddressSpace(target, .global_constant), - }, - }); - const opt_ptr_stack_trace_ty = try mod.optionalType(ptr_stack_trace_ty.toIntern()); - mod.null_stack_trace = try mod.intern(.{ .opt = .{ - .ty = opt_ptr_stack_trace_ty.toIntern(), - .val = .none, - } }); - } -} - /// Backends depend on panic decls being available when lowering safety-checked /// instructions. This function ensures the panic function will be available to /// be called during that time. @@ -27029,32 +27749,6 @@ fn preparePanicId(sema: *Sema, block: *Block, panic_id: Module.PanicId) !InternP return msg_decl_index; } -fn addSafetyCheck( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - ok: Air.Inst.Ref, - panic_id: Module.PanicId, -) !void { - const gpa = sema.gpa; - assert(!parent_block.is_comptime); - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .src_decl = parent_block.src_decl, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - }; - - defer fail_block.instructions.deinit(gpa); - - try sema.safetyPanic(&fail_block, src, panic_id); - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); -} - fn addSafetyCheckExtra( sema: *Sema, parent_block: *Block, @@ -27062,6 +27756,9 @@ fn addSafetyCheckExtra( fail_block: *Block, ) !void { const gpa = sema.gpa; + if (fail_block.instructions.items.len == 0) { + _ = try fail_block.addNoOp(.trap); + } try parent_block.instructions.ensureUnusedCapacity(gpa, 1); @@ -27110,186 +27807,6 @@ fn addSafetyCheckExtra( parent_block.instructions.appendAssumeCapacity(block_inst); } -fn panicWithMsg(sema: *Sema, block: *Block, src: LazySrcLoc, msg_inst: Air.Inst.Ref, operation: CallOperation) !void { - const mod = sema.mod; - - if (!mod.backendSupportsFeature(.panic_fn)) { - _ = try block.addNoOp(.trap); - return; - } - - try sema.prepareSimplePanic(block); - - const panic_func = mod.funcInfo(mod.panic_func_index); - const panic_fn = try sema.analyzeDeclVal(block, src, panic_func.owner_decl); - const null_stack_trace = Air.internedToRef(mod.null_stack_trace); - - const opt_usize_ty = try mod.optionalType(.usize_type); - const null_ret_addr = Air.internedToRef((try mod.intern(.{ .opt = .{ - .ty = opt_usize_ty.toIntern(), - .val = .none, - } }))); - try sema.callBuiltin(block, src, panic_fn, .auto, &.{ msg_inst, null_stack_trace, null_ret_addr }, operation); -} - -fn panicUnwrapError( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - operand: Air.Inst.Ref, - unwrap_err_tag: Air.Inst.Tag, - is_non_err_tag: Air.Inst.Tag, -) !void { - assert(!parent_block.is_comptime); - const ok = try parent_block.addUnOp(is_non_err_tag, operand); - if (!sema.mod.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .unwrap_error); - } - const gpa = sema.gpa; - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .src_decl = parent_block.src_decl, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - }; - - defer fail_block.instructions.deinit(gpa); - - { - if (!sema.mod.backendSupportsFeature(.panic_unwrap_error)) { - _ = try fail_block.addNoOp(.trap); - } else { - const panic_fn = try sema.getBuiltin("panicUnwrapError"); - const err = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); - const err_return_trace = try sema.getErrorReturnTrace(&fail_block); - const args: [2]Air.Inst.Ref = .{ err_return_trace, err }; - try sema.callBuiltin(&fail_block, src, panic_fn, .auto, &args, .@"safety check"); - } - } - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); -} - -fn panicIndexOutOfBounds( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - index: Air.Inst.Ref, - len: Air.Inst.Ref, - cmp_op: Air.Inst.Tag, -) !void { - assert(!parent_block.is_comptime); - const ok = try parent_block.addBinOp(cmp_op, index, len); - if (!sema.mod.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .index_out_of_bounds); - } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicOutOfBounds", &.{ index, len }); -} - -fn panicInactiveUnionField( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - active_tag: Air.Inst.Ref, - wanted_tag: Air.Inst.Ref, -) !void { - assert(!parent_block.is_comptime); - const ok = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag); - if (!sema.mod.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .inactive_union_field); - } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicInactiveUnionField", &.{ active_tag, wanted_tag }); -} - -fn panicSentinelMismatch( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - maybe_sentinel: ?Value, - sentinel_ty: Type, - ptr: Air.Inst.Ref, - sentinel_index: Air.Inst.Ref, -) !void { - assert(!parent_block.is_comptime); - const mod = sema.mod; - const expected_sentinel_val = maybe_sentinel orelse return; - const expected_sentinel = Air.internedToRef(expected_sentinel_val.toIntern()); - - const ptr_ty = sema.typeOf(ptr); - const actual_sentinel = if (ptr_ty.isSlice(mod)) - try parent_block.addBinOp(.slice_elem_val, ptr, sentinel_index) - else blk: { - const elem_ptr_ty = try sema.elemPtrType(ptr_ty, null); - const sentinel_ptr = try parent_block.addPtrElemPtr(ptr, sentinel_index, elem_ptr_ty); - break :blk try parent_block.addTyOp(.load, sentinel_ty, sentinel_ptr); - }; - - const ok = if (sentinel_ty.zigTypeTag(mod) == .Vector) ok: { - const eql = - try parent_block.addCmpVector(expected_sentinel, actual_sentinel, .eq); - break :ok try parent_block.addInst(.{ - .tag = .reduce, - .data = .{ .reduce = .{ - .operand = eql, - .operation = .And, - } }, - }); - } else if (sentinel_ty.isSelfComparable(mod, true)) - try parent_block.addBinOp(.cmp_eq, expected_sentinel, actual_sentinel) - else { - const panic_fn = try sema.getBuiltin("checkNonScalarSentinel"); - const args: [2]Air.Inst.Ref = .{ expected_sentinel, actual_sentinel }; - try sema.callBuiltin(parent_block, src, panic_fn, .auto, &args, .@"safety check"); - return; - }; - - if (!sema.mod.comp.formatted_panics) { - return sema.addSafetyCheck(parent_block, src, ok, .sentinel_mismatch); - } - try sema.safetyCheckFormatted(parent_block, src, ok, "panicSentinelMismatch", &.{ expected_sentinel, actual_sentinel }); -} - -fn safetyCheckFormatted( - sema: *Sema, - parent_block: *Block, - src: LazySrcLoc, - ok: Air.Inst.Ref, - func: []const u8, - args: []const Air.Inst.Ref, -) CompileError!void { - assert(sema.mod.comp.formatted_panics); - const gpa = sema.gpa; - - var fail_block: Block = .{ - .parent = parent_block, - .sema = sema, - .src_decl = parent_block.src_decl, - .namespace = parent_block.namespace, - .instructions = .{}, - .inlining = parent_block.inlining, - .is_comptime = false, - }; - - defer fail_block.instructions.deinit(gpa); - - if (!sema.mod.backendSupportsFeature(.safety_check_formatted)) { - _ = try fail_block.addNoOp(.trap); - } else { - const panic_fn = try sema.getBuiltin(func); - try sema.callBuiltin(&fail_block, src, panic_fn, .auto, args, .@"safety check"); - } - try sema.addSafetyCheckExtra(parent_block, ok, &fail_block); -} - -fn safetyPanic(sema: *Sema, block: *Block, src: LazySrcLoc, panic_id: Module.PanicId) CompileError!void { - const msg_decl_index = try sema.preparePanicId(block, panic_id); - const msg_inst = try sema.analyzeDeclVal(block, src, msg_decl_index); - try sema.panicWithMsg(block, src, msg_inst, .@"safety check"); -} - fn emitBackwardBranch(sema: *Sema, block: *Block, src: LazySrcLoc) !void { sema.branch_count += 1; if (sema.branch_count > sema.branch_quota) { @@ -28344,7 +28861,7 @@ fn unionFieldPtr( // TODO would it be better if get_union_tag supported pointers to unions? const union_val = try block.addTyOp(.load, union_ty, union_ptr); const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_val); - try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag); + try RuntimeSafety.checkAccessInactiveUnionField(sema, block, src, active_tag, wanted_tag); } if (field_ty.zigTypeTag(mod) == .NoReturn) { _ = try block.addNoOp(.unreach); @@ -28418,7 +28935,7 @@ fn unionFieldVal( const wanted_tag_val = try zcu.enumValueFieldIndex(Type.fromInterned(union_obj.enum_tag_ty), enum_field_index); const wanted_tag = Air.internedToRef(wanted_tag_val.toIntern()); const active_tag = try block.addTyOp(.get_union_tag, Type.fromInterned(union_obj.enum_tag_ty), union_byval); - try sema.panicInactiveUnionField(block, src, active_tag, wanted_tag); + try RuntimeSafety.checkAccessInactiveUnionField(sema, block, src, active_tag, wanted_tag); } if (field_ty.zigTypeTag(zcu) == .NoReturn) { _ = try block.addNoOp(.unreach); @@ -28783,7 +29300,7 @@ fn elemValArray( if (maybe_index_val == null) { const len_inst = try mod.intRef(Type.usize, array_len); const cmp_op: Air.Inst.Tag = if (array_sent != null) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try RuntimeSafety.checkAccessOutOfBounds(sema, block, src, elem_index, len_inst, cmp_op); } } @@ -28851,7 +29368,7 @@ fn elemPtrArray( if (oob_safety and block.wantSafety() and offset == null) { const len_inst = try mod.intRef(Type.usize, array_len); const cmp_op: Air.Inst.Tag = if (array_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try RuntimeSafety.checkAccessOutOfBounds(sema, block, src, elem_index, len_inst, cmp_op); } return block.addPtrElemPtr(array_ptr, elem_index, elem_ptr_ty); @@ -28909,7 +29426,7 @@ fn elemValSlice( else try block.addTyOp(.slice_len, Type.usize, slice); const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try RuntimeSafety.checkAccessOutOfBounds(sema, block, src, elem_index, len_inst, cmp_op); } try sema.queueFullTypeResolution(sema.typeOf(slice)); return block.addBinOp(.slice_elem_val, slice, elem_index); @@ -28969,7 +29486,7 @@ fn elemPtrSlice( break :len try block.addTyOp(.slice_len, Type.usize, slice); }; const cmp_op: Air.Inst.Tag = if (slice_sent) .cmp_lte else .cmp_lt; - try sema.panicIndexOutOfBounds(block, src, elem_index, len_inst, cmp_op); + try RuntimeSafety.checkAccessOutOfBounds(sema, block, src, elem_index, len_inst, cmp_op); } return block.addSliceElemPtr(slice, elem_index, elem_ptr_ty); } @@ -31188,7 +31705,7 @@ fn coerceCompatiblePtrs( const len_zero = try block.addBinOp(.cmp_eq, len, .zero_usize); break :ok try block.addBinOp(.bool_or, len_zero, is_non_zero); } else is_non_zero; - try sema.addSafetyCheck(block, inst_src, ok, .cast_to_null); + try RuntimeSafety.checkCastToPointerFromInvalid(sema, block, inst_src, dest_ty, ptr_int, ok); } const new_ptr = try sema.bitCast(block, dest_ty, inst, inst_src, null); try sema.checkKnownAllocPtr(block, inst, new_ptr); @@ -32370,515 +32887,6 @@ fn analyzePtrIsNonErr( } } -fn analyzeSlice( - sema: *Sema, - block: *Block, - src: LazySrcLoc, - ptr_ptr: Air.Inst.Ref, - uncasted_start: Air.Inst.Ref, - uncasted_end_opt: Air.Inst.Ref, - sentinel_opt: Air.Inst.Ref, - sentinel_src: LazySrcLoc, - ptr_src: LazySrcLoc, - start_src: LazySrcLoc, - end_src: LazySrcLoc, - by_length: bool, -) CompileError!Air.Inst.Ref { - const mod = sema.mod; - // Slice expressions can operate on a variable whose type is an array. This requires - // the slice operand to be a pointer. In the case of a non-array, it will be a double pointer. - const ptr_ptr_ty = sema.typeOf(ptr_ptr); - const ptr_ptr_child_ty = switch (ptr_ptr_ty.zigTypeTag(mod)) { - .Pointer => ptr_ptr_ty.childType(mod), - else => return sema.fail(block, ptr_src, "expected pointer, found '{}'", .{ptr_ptr_ty.fmt(mod)}), - }; - - var array_ty = ptr_ptr_child_ty; - var slice_ty = ptr_ptr_ty; - var ptr_or_slice = ptr_ptr; - var elem_ty: Type = undefined; - var ptr_sentinel: ?Value = null; - switch (ptr_ptr_child_ty.zigTypeTag(mod)) { - .Array => { - ptr_sentinel = ptr_ptr_child_ty.sentinel(mod); - elem_ty = ptr_ptr_child_ty.childType(mod); - }, - .Pointer => switch (ptr_ptr_child_ty.ptrSize(mod)) { - .One => { - const double_child_ty = ptr_ptr_child_ty.childType(mod); - ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src); - if (double_child_ty.zigTypeTag(mod) == .Array) { - ptr_sentinel = double_child_ty.sentinel(mod); - slice_ty = ptr_ptr_child_ty; - array_ty = double_child_ty; - elem_ty = double_child_ty.childType(mod); - } else { - const bounds_error_message = "slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1]"; - if (uncasted_end_opt == .none) { - return sema.fail(block, src, bounds_error_message, .{}); - } - const start_value = try sema.resolveConstDefinedValue( - block, - start_src, - uncasted_start, - .{ .needed_comptime_reason = bounds_error_message }, - ); - - const end_value = try sema.resolveConstDefinedValue( - block, - end_src, - uncasted_end_opt, - .{ .needed_comptime_reason = bounds_error_message }, - ); - - if (try sema.compareScalar(start_value, .neq, end_value, Type.comptime_int)) { - if (try sema.compareScalar(start_value, .neq, Value.zero_comptime_int, Type.comptime_int)) { - const msg = msg: { - const msg = try sema.errMsg(block, start_src, bounds_error_message, .{}); - errdefer msg.destroy(sema.gpa); - try sema.errNote( - block, - start_src, - msg, - "expected '{}', found '{}'", - .{ - Value.zero_comptime_int.fmtValue(mod, sema), - start_value.fmtValue(mod, sema), - }, - ); - break :msg msg; - }; - return sema.failWithOwnedErrorMsg(block, msg); - } else if (try sema.compareScalar(end_value, .neq, Value.one_comptime_int, Type.comptime_int)) { - const msg = msg: { - const msg = try sema.errMsg(block, end_src, bounds_error_message, .{}); - errdefer msg.destroy(sema.gpa); - try sema.errNote( - block, - end_src, - msg, - "expected '{}', found '{}'", - .{ - Value.one_comptime_int.fmtValue(mod, sema), - end_value.fmtValue(mod, sema), - }, - ); - break :msg msg; - }; - return sema.failWithOwnedErrorMsg(block, msg); - } - } else { - if (try sema.compareScalar(end_value, .gt, Value.one_comptime_int, Type.comptime_int)) { - return sema.fail( - block, - end_src, - "end index {} out of bounds for slice of single-item pointer", - .{end_value.fmtValue(mod, sema)}, - ); - } - } - - array_ty = try mod.arrayType(.{ - .len = 1, - .child = double_child_ty.toIntern(), - }); - const ptr_info = ptr_ptr_child_ty.ptrInfo(mod); - slice_ty = try mod.ptrType(.{ - .child = array_ty.toIntern(), - .flags = .{ - .alignment = ptr_info.flags.alignment, - .is_const = ptr_info.flags.is_const, - .is_allowzero = ptr_info.flags.is_allowzero, - .is_volatile = ptr_info.flags.is_volatile, - .address_space = ptr_info.flags.address_space, - }, - }); - elem_ty = double_child_ty; - } - }, - .Many, .C => { - ptr_sentinel = ptr_ptr_child_ty.sentinel(mod); - ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src); - slice_ty = ptr_ptr_child_ty; - array_ty = ptr_ptr_child_ty; - elem_ty = ptr_ptr_child_ty.childType(mod); - - if (ptr_ptr_child_ty.ptrSize(mod) == .C) { - if (try sema.resolveDefinedValue(block, ptr_src, ptr_or_slice)) |ptr_val| { - if (ptr_val.isNull(mod)) { - return sema.fail(block, src, "slice of null pointer", .{}); - } - } - } - }, - .Slice => { - ptr_sentinel = ptr_ptr_child_ty.sentinel(mod); - ptr_or_slice = try sema.analyzeLoad(block, src, ptr_ptr, ptr_src); - slice_ty = ptr_ptr_child_ty; - array_ty = ptr_ptr_child_ty; - elem_ty = ptr_ptr_child_ty.childType(mod); - }, - }, - else => return sema.fail(block, src, "slice of non-array type '{}'", .{ptr_ptr_child_ty.fmt(mod)}), - } - - const ptr = if (slice_ty.isSlice(mod)) - try sema.analyzeSlicePtr(block, ptr_src, ptr_or_slice, slice_ty) - else if (array_ty.zigTypeTag(mod) == .Array) ptr: { - var manyptr_ty_key = mod.intern_pool.indexToKey(slice_ty.toIntern()).ptr_type; - assert(manyptr_ty_key.child == array_ty.toIntern()); - assert(manyptr_ty_key.flags.size == .One); - manyptr_ty_key.child = elem_ty.toIntern(); - manyptr_ty_key.flags.size = .Many; - break :ptr try sema.coerceCompatiblePtrs(block, try sema.ptrType(manyptr_ty_key), ptr_or_slice, ptr_src); - } else ptr_or_slice; - - const start = try sema.coerce(block, Type.usize, uncasted_start, start_src); - const new_ptr = try sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, ptr_src, start_src); - const new_ptr_ty = sema.typeOf(new_ptr); - - // true if and only if the end index of the slice, implicitly or explicitly, equals - // the length of the underlying object being sliced. we might learn the length of the - // underlying object because it is an array (which has the length in the type), or - // we might learn of the length because it is a comptime-known slice value. - var end_is_len = uncasted_end_opt == .none; - const end = e: { - if (array_ty.zigTypeTag(mod) == .Array) { - const len_val = try mod.intValue(Type.usize, array_ty.arrayLen(mod)); - - if (!end_is_len) { - const end = if (by_length) end: { - const len = try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - const uncasted_end = try sema.analyzeArithmetic(block, .add, start, len, src, start_src, end_src, false); - break :end try sema.coerce(block, Type.usize, uncasted_end, end_src); - } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| { - const len_s_val = try mod.intValue( - Type.usize, - array_ty.arrayLenIncludingSentinel(mod), - ); - if (!(try sema.compareAll(end_val, .lte, len_s_val, Type.usize))) { - const sentinel_label: []const u8 = if (array_ty.sentinel(mod) != null) - " +1 (sentinel)" - else - ""; - - return sema.fail( - block, - end_src, - "end index {} out of bounds for array of length {}{s}", - .{ - end_val.fmtValue(mod, sema), - len_val.fmtValue(mod, sema), - sentinel_label, - }, - ); - } - - // end_is_len is only true if we are NOT using the sentinel - // length. For sentinel-length, we don't want the type to - // contain the sentinel. - if (end_val.eql(len_val, Type.usize, mod)) { - end_is_len = true; - } - } - break :e end; - } - - break :e Air.internedToRef(len_val.toIntern()); - } else if (slice_ty.isSlice(mod)) { - if (!end_is_len) { - const end = if (by_length) end: { - const len = try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - const uncasted_end = try sema.analyzeArithmetic(block, .add, start, len, src, start_src, end_src, false); - break :end try sema.coerce(block, Type.usize, uncasted_end, end_src); - } else try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| { - if (try sema.resolveValue(ptr_or_slice)) |slice_val| { - if (slice_val.isUndef(mod)) { - return sema.fail(block, src, "slice of undefined", .{}); - } - const has_sentinel = slice_ty.sentinel(mod) != null; - const slice_len = try slice_val.sliceLen(sema); - const len_plus_sent = slice_len + @intFromBool(has_sentinel); - const slice_len_val_with_sentinel = try mod.intValue(Type.usize, len_plus_sent); - if (!(try sema.compareAll(end_val, .lte, slice_len_val_with_sentinel, Type.usize))) { - const sentinel_label: []const u8 = if (has_sentinel) - " +1 (sentinel)" - else - ""; - - return sema.fail( - block, - end_src, - "end index {} out of bounds for slice of length {d}{s}", - .{ - end_val.fmtValue(mod, sema), - try slice_val.sliceLen(sema), - sentinel_label, - }, - ); - } - - // If the slice has a sentinel, we consider end_is_len - // is only true if it equals the length WITHOUT the - // sentinel, so we don't add a sentinel type. - const slice_len_val = try mod.intValue(Type.usize, slice_len); - if (end_val.eql(slice_len_val, Type.usize, mod)) { - end_is_len = true; - } - } - } - break :e end; - } - break :e try sema.analyzeSliceLen(block, src, ptr_or_slice); - } - if (!end_is_len) { - if (by_length) { - const len = try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - const uncasted_end = try sema.analyzeArithmetic(block, .add, start, len, src, start_src, end_src, false); - break :e try sema.coerce(block, Type.usize, uncasted_end, end_src); - } else break :e try sema.coerce(block, Type.usize, uncasted_end_opt, end_src); - } - return sema.analyzePtrArithmetic(block, src, ptr, start, .ptr_add, ptr_src, start_src); - }; - - const sentinel = s: { - if (sentinel_opt != .none) { - const casted = try sema.coerce(block, elem_ty, sentinel_opt, sentinel_src); - break :s try sema.resolveConstDefinedValue(block, sentinel_src, casted, .{ - .needed_comptime_reason = "slice sentinel must be comptime-known", - }); - } - // If we are slicing to the end of something that is sentinel-terminated - // then the resulting slice type is also sentinel-terminated. - if (end_is_len) { - if (ptr_sentinel) |sent| { - break :s sent; - } - } - break :s null; - }; - const slice_sentinel = if (sentinel_opt != .none) sentinel else null; - - var checked_start_lte_end = by_length; - var runtime_src: ?LazySrcLoc = null; - - // requirement: start <= end - if (try sema.resolveDefinedValue(block, end_src, end)) |end_val| { - if (try sema.resolveDefinedValue(block, start_src, start)) |start_val| { - if (!by_length and !(try sema.compareAll(start_val, .lte, end_val, Type.usize))) { - return sema.fail( - block, - start_src, - "start index {} is larger than end index {}", - .{ - start_val.fmtValue(mod, sema), - end_val.fmtValue(mod, sema), - }, - ); - } - checked_start_lte_end = true; - if (try sema.resolveValue(new_ptr)) |ptr_val| sentinel_check: { - const expected_sentinel = sentinel orelse break :sentinel_check; - const start_int = start_val.getUnsignedInt(mod).?; - const end_int = end_val.getUnsignedInt(mod).?; - const sentinel_index = try sema.usizeCast(block, end_src, end_int - start_int); - - const many_ptr_ty = try mod.manyConstPtrType(elem_ty); - const many_ptr_val = try mod.getCoerced(ptr_val, many_ptr_ty); - const elem_ptr = try many_ptr_val.ptrElem(sentinel_index, sema); - const res = try sema.pointerDerefExtra(block, src, elem_ptr); - const actual_sentinel = switch (res) { - .runtime_load => break :sentinel_check, - .val => |v| v, - .needed_well_defined => |ty| return sema.fail( - block, - src, - "comptime dereference requires '{}' to have a well-defined layout", - .{ty.fmt(mod)}, - ), - .out_of_bounds => |ty| return sema.fail( - block, - end_src, - "slice end index {d} exceeds bounds of containing decl of type '{}'", - .{ end_int, ty.fmt(mod) }, - ), - }; - - if (!actual_sentinel.eql(expected_sentinel, elem_ty, mod)) { - const msg = msg: { - const msg = try sema.errMsg(block, src, "value in memory does not match slice sentinel", .{}); - errdefer msg.destroy(sema.gpa); - try sema.errNote(block, src, msg, "expected '{}', found '{}'", .{ - expected_sentinel.fmtValue(mod, sema), - actual_sentinel.fmtValue(mod, sema), - }); - - break :msg msg; - }; - return sema.failWithOwnedErrorMsg(block, msg); - } - } else { - runtime_src = ptr_src; - } - } else { - runtime_src = start_src; - } - } else { - runtime_src = end_src; - } - - if (!checked_start_lte_end and block.wantSafety() and !block.is_comptime) { - // requirement: start <= end - assert(!block.is_comptime); - try sema.requireRuntimeBlock(block, src, runtime_src.?); - const ok = try block.addBinOp(.cmp_lte, start, end); - if (!sema.mod.comp.formatted_panics) { - try sema.addSafetyCheck(block, src, ok, .start_index_greater_than_end); - } else { - try sema.safetyCheckFormatted(block, src, ok, "panicStartGreaterThanEnd", &.{ start, end }); - } - } - const new_len = if (by_length) - try sema.coerce(block, Type.usize, uncasted_end_opt, end_src) - else - try sema.analyzeArithmetic(block, .sub, end, start, src, end_src, start_src, false); - const opt_new_len_val = try sema.resolveDefinedValue(block, src, new_len); - - const new_ptr_ty_info = new_ptr_ty.ptrInfo(mod); - const new_allowzero = new_ptr_ty_info.flags.is_allowzero and sema.typeOf(ptr).ptrSize(mod) != .C; - - if (opt_new_len_val) |new_len_val| { - const new_len_int = try new_len_val.toUnsignedIntAdvanced(sema); - - const return_ty = try sema.ptrType(.{ - .child = (try mod.arrayType(.{ - .len = new_len_int, - .sentinel = if (sentinel) |s| s.toIntern() else .none, - .child = elem_ty.toIntern(), - })).toIntern(), - .flags = .{ - .alignment = new_ptr_ty_info.flags.alignment, - .is_const = new_ptr_ty_info.flags.is_const, - .is_allowzero = new_allowzero, - .is_volatile = new_ptr_ty_info.flags.is_volatile, - .address_space = new_ptr_ty_info.flags.address_space, - }, - }); - - const opt_new_ptr_val = try sema.resolveValue(new_ptr); - const new_ptr_val = opt_new_ptr_val orelse { - const result = try block.addBitCast(return_ty, new_ptr); - if (block.wantSafety()) { - // requirement: slicing C ptr is non-null - if (ptr_ptr_child_ty.isCPtr(mod)) { - const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true); - try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null); - } - - bounds_check: { - const actual_len = if (array_ty.zigTypeTag(mod) == .Array) - try mod.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(mod)) - else if (slice_ty.isSlice(mod)) l: { - const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice); - break :l if (slice_ty.sentinel(mod) == null) - slice_len_inst - else - try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src, true); - } else break :bounds_check; - - const actual_end = if (slice_sentinel != null) - try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src, true) - else - end; - - try sema.panicIndexOutOfBounds(block, src, actual_end, actual_len, .cmp_lte); - } - - // requirement: result[new_len] == slice_sentinel - try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); - } - return result; - }; - - if (!new_ptr_val.isUndef(mod)) { - return Air.internedToRef((try mod.getCoerced(new_ptr_val, return_ty)).toIntern()); - } - - // Special case: @as([]i32, undefined)[x..x] - if (new_len_int == 0) { - return mod.undefRef(return_ty); - } - - return sema.fail(block, src, "non-zero length slice of undefined pointer", .{}); - } - - const return_ty = try sema.ptrType(.{ - .child = elem_ty.toIntern(), - .sentinel = if (sentinel) |s| s.toIntern() else .none, - .flags = .{ - .size = .Slice, - .alignment = new_ptr_ty_info.flags.alignment, - .is_const = new_ptr_ty_info.flags.is_const, - .is_volatile = new_ptr_ty_info.flags.is_volatile, - .is_allowzero = new_allowzero, - .address_space = new_ptr_ty_info.flags.address_space, - }, - }); - - try sema.requireRuntimeBlock(block, src, runtime_src.?); - if (block.wantSafety()) { - // requirement: slicing C ptr is non-null - if (ptr_ptr_child_ty.isCPtr(mod)) { - const is_non_null = try sema.analyzeIsNull(block, ptr_src, ptr, true); - try sema.addSafetyCheck(block, src, is_non_null, .unwrap_null); - } - - // requirement: end <= len - const opt_len_inst = if (array_ty.zigTypeTag(mod) == .Array) - try mod.intRef(Type.usize, array_ty.arrayLenIncludingSentinel(mod)) - else if (slice_ty.isSlice(mod)) blk: { - if (try sema.resolveDefinedValue(block, src, ptr_or_slice)) |slice_val| { - // we don't need to add one for sentinels because the - // underlying value data includes the sentinel - break :blk try mod.intRef(Type.usize, try slice_val.sliceLen(sema)); - } - - const slice_len_inst = try block.addTyOp(.slice_len, Type.usize, ptr_or_slice); - if (slice_ty.sentinel(mod) == null) break :blk slice_len_inst; - - // we have to add one because slice lengths don't include the sentinel - break :blk try sema.analyzeArithmetic(block, .add, slice_len_inst, .one, src, end_src, end_src, true); - } else null; - if (opt_len_inst) |len_inst| { - const actual_end = if (slice_sentinel != null) - try sema.analyzeArithmetic(block, .add, end, .one, src, end_src, end_src, true) - else - end; - try sema.panicIndexOutOfBounds(block, src, actual_end, len_inst, .cmp_lte); - } - - // requirement: start <= end - try sema.panicIndexOutOfBounds(block, src, start, end, .cmp_lte); - } - const result = try block.addInst(.{ - .tag = .slice, - .data = .{ .ty_pl = .{ - .ty = Air.internedToRef(return_ty.toIntern()), - .payload = try sema.addExtra(Air.Bin{ - .lhs = new_ptr, - .rhs = new_len, - }), - } }, - }); - if (block.wantSafety()) { - // requirement: result[new_len] == slice_sentinel - try sema.panicSentinelMismatch(block, src, slice_sentinel, elem_ty, result, new_len); - } - return result; -} - /// Asserts that lhs and rhs types are both numeric. fn cmpNumeric( sema: *Sema, @@ -38643,6 +38651,1222 @@ fn maybeDerefSliceAsArray( return sema.pointerDeref(block, src, casted_ptr, ptr_ty); } +/// Returns the number of `elem_ty` stored by type `val_ty`. +/// `val_ty` == `elem_ty` => 1 +/// `val_ty` == `@Vector(len, elem_ty)` => @typeInfo(val_ty).Vector.len +/// `val_ty` == `[len]elem_ty` => @typeInfo(val_ty).Array.len +/// `val_ty` == `[len]@Vector(len, elem_ty)` => @typeInfo(val_ty).Array.len * +/// @typeInfo(@typeInfo(val_ty).Array.child).Vector.len +fn reinterpretLength( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + elem_ty: Type, + val_ty: Type, +) !u64 { + if (elem_ty.ip_index == val_ty.ip_index) { + return 1; + } + if (val_ty.isArrayOrVector(sema.mod)) { + const val_ty_tag: std.builtin.TypeId = val_ty.zigTypeTag(sema.mod); + const child_ty: Type = Type.elemType2(val_ty, sema.mod); + if (val_ty_tag == .Array) { + return val_ty.arrayLen(sema.mod) * try sema.reinterpretLength(block, src, elem_ty, child_ty); + } + if (val_ty_tag == .Vector) { + return val_ty.vectorLen(sema.mod) * try sema.reinterpretLength(block, src, elem_ty, child_ty); + } + } + return sema.fail(block, src, "type '{}' cannot be reinterpreted as type '{}'", .{ + val_ty.fmt(sema.mod), + elem_ty.fmt(sema.mod), + }); +} +/// Returns the number of remaining elements of `elem_ty` in the declaration +/// containing `ptr_val`. +fn reinterpretLengthOfContainingDecl( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + ptr_val: Value, + elem_ty: Type, +) !?u64 { + const ptr_key: InternPool.Key.Ptr = sema.mod.intern_pool.indexToKey(Value.toIntern(ptr_val)).ptr; + switch (ptr_key.base_addr) { + .arr_elem => |elem| if (try reinterpretLengthOfContainingDecl(sema, block, src, Value.fromInterned(elem.base), elem_ty)) |elems| { + const child_ty: Type = Type.elemType2(Type.fromInterned(sema.mod.intern_pool.typeOf(elem.base)), sema.mod); + if (child_ty.ip_index != elem_ty.ip_index) { + return sema.fail(block, src, "type '{}' cannot be reinterpreted as type '{}'", .{ + child_ty.fmt(sema.mod), + elem_ty.fmt(sema.mod), + }); + } + return elems - elem.index; + }, + .comptime_alloc => |comptime_alloc| { + const val_ty: Type = sema.getComptimeAlloc(comptime_alloc).val.typeOf(sema.mod); + return try reinterpretLength(sema, block, src, elem_ty, val_ty); + }, + .anon_decl => |anon_decl| { + const decl_ty: Type = Type.fromInterned(sema.mod.intern_pool.typeOf(anon_decl.val)); + return try reinterpretLength(sema, block, src, elem_ty, decl_ty); + }, + .decl => |decl| { + const decl_ptr: *Decl = sema.mod.declPtr(decl); + const decl_ty: Type = (try decl_ptr.valueOrFail()).typeOf(sema.mod); + return try reinterpretLength(sema, block, src, elem_ty, decl_ty); + }, + inline .eu_payload, .opt_payload, .field, .comptime_field => |_, tag| { + return sema.fail(block, src, "TODO: handle comptime slice manyptr without runtime bits for '{}'", .{tag}); + }, + .int => {}, + } + return null; +} +/// Returns the number of remaining bytes (from the pointer byte offset) in the +/// declaration containing `ptr_val`. +fn abiSizeOfContainingDecl( + sema: *Sema, + block: *Block, + src: LazySrcLoc, + ptr_val: Value, +) !?u64 { + const ptr_key: InternPool.Key.Ptr = sema.mod.intern_pool.indexToKey(Value.toIntern(ptr_val)).ptr; + switch (ptr_key.base_addr) { + .decl => |decl| { + const decl_ptr: *Decl = sema.mod.declPtr(decl); + const decl_ty: Type = (try decl_ptr.valueOrFail()).typeOf(sema.mod); + return try sema.typeAbiSize(decl_ty) - ptr_key.byte_offset; + }, + .anon_decl => |anon_decl| { + const decl_ty: Type = Type.fromInterned(sema.mod.intern_pool.typeOf(anon_decl.val)); + return try sema.typeAbiSize(decl_ty) - ptr_key.byte_offset; + }, + .field => |field| if (try abiSizeOfContainingDecl(sema, block, src, Value.fromInterned(field.base))) |memsz| { + const container_ty: Type = Type.childType(Type.fromInterned(sema.mod.intern_pool.typeOf(field.base)), sema.mod); + const field_offset: u64 = container_ty.structFieldOffset(try sema.usizeCast(block, src, field.index), sema.mod); + return (memsz - field_offset) - ptr_key.byte_offset; + }, + .arr_elem => |elem| if (try abiSizeOfContainingDecl(sema, block, src, Value.fromInterned(elem.base))) |memsz| { + const child_ty: Type = Type.elemType2(Type.fromInterned(sema.mod.intern_pool.typeOf(elem.base)), sema.mod); + const child_ty_size: u64 = try sema.typeAbiSize(child_ty); + return (memsz - (child_ty_size * elem.index)) - ptr_key.byte_offset; + }, + .comptime_field => |comptime_field| { + const field_ty: Type = Type.fromInterned(sema.mod.intern_pool.typeOf(comptime_field)); + return try sema.typeAbiSize(field_ty) - ptr_key.byte_offset; + }, + .comptime_alloc => |comptime_alloc| { + const val_ty: Type = sema.getComptimeAlloc(comptime_alloc).val.typeOf(sema.mod); + return try sema.typeAbiSize(val_ty) - ptr_key.byte_offset; + }, + inline .eu_payload, .opt_payload => |_, tag| { + return sema.fail(block, src, "TODO: handle comptime slice manyptr with runtime bits for '{}'", .{tag}); + }, + .int => {}, + } + return null; +} + +const RuntimeSafety = struct { + const Cast = struct { + to: Type, + from: Type, + }; + const PanicCause = union(std.builtin.PanicId) { + message, + unwrapped_error, + returned_noreturn, + reached_unreachable, + corrupt_switch, + accessed_out_of_bounds, + accessed_out_of_order, + accessed_out_of_order_extra, + accessed_inactive_field: Type, + accessed_null_value, + divided_by_zero, + memcpy_argument_aliasing, + mismatched_memcpy_argument_lengths, + mismatched_for_loop_capture_lengths, + mismatched_sentinel: Type, + mismatched_null_sentinel, + shl_overflowed: Type, + shr_overflowed: Type, + shift_amt_overflowed: Type, + div_with_remainder: Type, + mul_overflowed: Type, + add_overflowed: Type, + sub_overflowed: Type, + div_overflowed: Type, + cast_truncated_data: Cast, + cast_to_enum_from_invalid: Type, + cast_to_error_from_invalid: Cast, + cast_to_ptr_from_invalid: Alignment, + cast_to_int_from_invalid: Cast, + cast_to_unsigned_from_negative: Cast, + }; + + /// Required to test values. Otherwise do nothing. + /// 1. User must enable the testing the panic condition. + /// 2. Backend must support testing the panic condition. + fn wantRuntimeSafetyCondition(sema: *Sema, panic_id: std.builtin.PanicId) bool { + return and switch (panic_id) { + .corrupt_switch => sema.mod.backendSupportsFeature(.is_named_enum_value), + .cast_to_error_from_invalid => sema.mod.backendSupportsFeature(.error_set_has_value), + .cast_to_enum_from_invalid => sema.mod.backendSupportsFeature(.is_named_enum_value), + else => true, + }; + } + /// Required to call special panic handler function with context data. + /// 1. User must enable formatted panics for the panic cause. + /// 2. Backend must support formatted panics. + /// 3. Panic definition must allow the data type. + fn wantRuntimeSafetyPanicData(sema: *Sema) bool { + return sema.mod.comp.formatted_panics and + sema.mod.backendSupportsFeature(.safety_check_formatted) and + sema.mod.safety.panic_fn_sig == .generic; + } + fn preparePanicData( + sema: *Sema, + fail_block: *Sema.Block, + src: std.zig.LazySrcLoc, + panic_cause: PanicCause, + panic_cause_inst: Air.Inst.Ref, + args: []const Air.Inst.Ref, + ) !Air.Inst.Ref { + if (wantRuntimeSafetyPanicData(sema)) { + return try fail_block.addAggregateInit(try callPanicData(sema, fail_block, src, panic_cause, panic_cause_inst), args); + } else { + return .void_value; + } + } + fn callPanicData( + sema: *Sema, + block: *Sema.Block, + src: std.zig.LazySrcLoc, + panic_cause: PanicCause, + panic_cause_inst: Air.Inst.Ref, + ) Module.CompileError!Type { + const branch_count: u32 = sema.branch_count; + defer sema.branch_count = branch_count; + const cache_ptr: ?*InternPool.Index = getSafetyCachePtr(sema, panic_cause, &sema.mod.safety.ty_cache); + if (cache_ptr) |ptr| { + if (ptr.* != .none) { + return Type.fromInterned(ptr.*); + } + } + const res: Air.Inst.Ref = try sema.analyzeCall( + block, + sema.mod.safety.panic_data_fn_inst, + sema.typeOf(sema.mod.safety.panic_data_fn_inst), + src, + src, + .compile_time, + false, + .{ .resolved = .{ .src = src, .args = &.{panic_cause_inst} } }, + null, + .call, + ); + const ret: Type = Air.Inst.Ref.toType(res); + if (cache_ptr) |ptr| { + ptr.* = ret.ip_index; + } + return ret; + } + fn callPanicFn( + sema: *Sema, + block: *Sema.Block, + src: std.zig.LazySrcLoc, + panic_cause: PanicCause, + all_args: *const [2]Air.Inst.Ref, + op: CallOperation, + ) !void { + const branch_count: u32 = sema.branch_count; + defer sema.branch_count = branch_count; + var buf: [2]Air.Inst.Ref = all_args.*; + var args: []Air.Inst.Ref = &buf; + const panic_id_inst: Air.Inst.Ref = try sema.coerce(block, Type.fromInterned(sema.mod.safety.panic_id_ty), args[0], src); + const cache_ptr: ?*InternPool.Index = getSafetyCachePtr(sema, panic_cause, &sema.mod.safety.fn_cache); + if (sema.mod.safety.panic_fn_sig == .simple) { + if (panic_cause == .message) { + args[0] = args[1]; + } else { + args[0] = panic_id_inst; + } + args.len = 1; + } + const panic_fn_inst = blk: { + if (cache_ptr) |ptr| { + if (ptr.* != .none) { + if (sema.mod.safety.panic_fn_sig != .simple) { + args = args[1..]; + } + break :blk Air.internedToRef(ptr.*); + } + } + break :blk sema.mod.safety.panic_fn_inst; + }; + const panic_fn_ty: Type = sema.typeOf(panic_fn_inst); + const res: Air.Inst.Ref = try sema.analyzeCall( + block, + panic_fn_inst, + panic_fn_ty, + src, + src, + .auto, + false, + .{ .resolved = .{ .src = src, .args = args } }, + null, + op, + ); + if (cache_ptr) |ptr| { + if (ptr.* == .none) { + const idx: usize = sema.air_instructions.len -% 2; + + assert(sema.typeOf(res).ip_index == .noreturn_type); + assert(sema.air_instructions.items(.tag)[idx] == .call); + + const operand: Air.Inst.Ref = sema.air_instructions.items(.data)[idx].pl_op.operand; + if (operand.toInterned()) |panic_fn_idx| { + ptr.* = panic_fn_idx; + } + } + } + } + + /// Returns the number of cache positions allowed for each panic ID. + fn cacheAllowance(id: std.builtin.PanicId) usize { + switch (id) { + .message, + .unwrapped_error, + .returned_noreturn, + .reached_unreachable, + .corrupt_switch, + .accessed_out_of_bounds, + .accessed_out_of_order, + .accessed_out_of_order_extra, + .accessed_null_value, + .divided_by_zero, + .memcpy_argument_aliasing, + .mismatched_null_sentinel, + .mismatched_memcpy_argument_lengths, + .mismatched_for_loop_capture_lengths, + => { + return 1; + }, + .shl_overflowed, + .shr_overflowed, + .shift_amt_overflowed, + .div_with_remainder, + .mul_overflowed, + .add_overflowed, + .sub_overflowed, + .div_overflowed, + => { + return 8; + }, + .cast_to_ptr_from_invalid => { + return 4; + }, + .cast_truncated_data => { + return 16; + }, + .cast_to_unsigned_from_negative => { + return 4; + }, + .mismatched_sentinel, + .accessed_inactive_field, + .cast_to_enum_from_invalid, + .cast_to_int_from_invalid, + .cast_to_error_from_invalid, + => { + return 0; + }, + } + } + fn getSafetyCachePtr( + sema: *Sema, + panic_cause: PanicCause, + cache: []InternPool.Index, + ) ?*InternPool.Index { + const idx: usize = switch (sema.mod.safety.panic_fn_sig) { + .simple => @intFromBool(panic_cause != .message), + .generic => cacheOffset(panic_cause) +% @as(usize, switch (panic_cause) { + .message, + .unwrapped_error, + .returned_noreturn, + .reached_unreachable, + .corrupt_switch, + .accessed_out_of_bounds, + .accessed_out_of_order, + .accessed_out_of_order_extra, + .accessed_null_value, + .divided_by_zero, + .memcpy_argument_aliasing, + .mismatched_memcpy_argument_lengths, + .mismatched_for_loop_capture_lengths, + .mismatched_null_sentinel, + => 0, + .shl_overflowed, + .shr_overflowed, + .shift_amt_overflowed, + .div_with_remainder, + .mul_overflowed, + .add_overflowed, + .sub_overflowed, + .div_overflowed, + => |int_type| switch (int_type.ip_index) { + .u8_type => 0, + .i8_type => 1, + .u16_type => 2, + .i16_type => 3, + .u32_type => 4, + .i32_type => 5, + .u64_type => 6, + .i64_type => 7, + else => { + return null; + }, + }, + .cast_to_ptr_from_invalid => |alignment| switch (alignment) { + .@"1" => 0, + .@"2" => 1, + .@"4" => 2, + .@"8" => 3, + else => { + return null; + }, + }, + .cast_truncated_data => |cast| switch (argTyId(.{ cast.to.ip_index, cast.from.ip_index })) { + argTyId(.{ .i64_type, .u64_type }) => 0, + argTyId(.{ .i32_type, .u32_type }) => 1, + argTyId(.{ .i16_type, .u16_type }) => 2, + argTyId(.{ .i8_type, .u8_type }) => 3, + argTyId(.{ .u32_type, .u64_type }) => 4, + argTyId(.{ .u16_type, .u64_type }) => 5, + argTyId(.{ .u8_type, .u64_type }) => 6, + argTyId(.{ .i32_type, .i64_type }) => 7, + argTyId(.{ .i16_type, .i64_type }) => 8, + argTyId(.{ .i8_type, .i64_type }) => 9, + argTyId(.{ .u16_type, .u32_type }) => 10, + argTyId(.{ .u8_type, .u32_type }) => 11, + argTyId(.{ .i16_type, .i32_type }) => 12, + argTyId(.{ .i8_type, .i32_type }) => 13, + argTyId(.{ .u8_type, .u16_type }) => 14, + argTyId(.{ .i8_type, .i16_type }) => 15, + else => { + return null; + }, + }, + .cast_to_unsigned_from_negative => |cast| switch (argTyId(.{ cast.to.ip_index, cast.from.ip_index })) { + argTyId(.{ .u64_type, .i64_type }) => 0, + argTyId(.{ .u32_type, .i32_type }) => 1, + argTyId(.{ .u16_type, .i16_type }) => 2, + argTyId(.{ .u8_type, .i8_type }) => 3, + else => { + return null; + }, + }, + .accessed_inactive_field, + .mismatched_sentinel, + + .cast_to_int_from_invalid, + .cast_to_error_from_invalid, + .cast_to_enum_from_invalid, + => { + return null; + }, + }), + .none => 1, + }; + return &cache[idx]; + } + fn preparePanicCause( + sema: *Sema, + panic_cause: PanicCause, + ) !Air.Inst.Ref { + try prepareRuntimeSafety(sema); + const tag_val: Value = try sema.mod.enumValueFieldIndex( + Type.fromInterned(sema.mod.safety.panic_id_ty), + @intFromEnum(panic_cause), + ); + return Air.internedToRef(try sema.mod.intern(.{ + .un = .{ + .ty = sema.mod.safety.panic_cause_ty, + .tag = Value.toIntern(tag_val), + .val = switch (panic_cause) { + // These panic causes each instantiate a single function. + .message, + .unwrapped_error, + .returned_noreturn, + .reached_unreachable, + .corrupt_switch, + .accessed_out_of_bounds, + .accessed_out_of_order, + .accessed_out_of_order_extra, + .accessed_null_value, + .divided_by_zero, + .memcpy_argument_aliasing, + .mismatched_memcpy_argument_lengths, + .mismatched_for_loop_capture_lengths, + .mismatched_null_sentinel, + => .void_value, + // These panic causes are generic depending on the type of + // one operand. + // + // If panic data is disabled these each instantiate a single + // function. + .accessed_inactive_field, + .mismatched_sentinel, + .shl_overflowed, + .shr_overflowed, + .shift_amt_overflowed, + .div_with_remainder, + .mul_overflowed, + .add_overflowed, + .sub_overflowed, + .div_overflowed, + .cast_to_enum_from_invalid, + => |payload| operand_ty: { + if (wantRuntimeSafetyPanicData(sema)) { + break :operand_ty Type.toIntern(payload); + } else { + break :operand_ty InternPool.Index.void_type; + } + }, + // This panic cause is generic depending on pointer + // alignment. + // + // If panic data is disabled all pointers instantiate a + // single function. + .cast_to_ptr_from_invalid => |alignment| ptr_align: { + if (wantRuntimeSafetyPanicData(sema)) { + const alignment_int: u64 = InternPool.Alignment.toByteUnits(alignment) orelse 0; + const ptr_align_val: Value = try sema.mod.intValue(Type.comptime_int, alignment_int); + break :ptr_align Value.toIntern(ptr_align_val); + } else { + break :ptr_align InternPool.Index.zero_usize; + } + }, + // These panic causes are generic depending on the source + // and destination types of a cast operation. + // + // If panic data is disabled each type of invalid cast + // instantiates a single function. + .cast_truncated_data, + .cast_to_int_from_invalid, + .cast_to_error_from_invalid, + .cast_to_unsigned_from_negative, + => |payload| cast_ty: { + if (wantRuntimeSafetyPanicData(sema)) { + break :cast_ty try sema.mod.intern(.{ .aggregate = .{ + .ty = sema.mod.safety.panic_cast_ty, + .storage = .{ .elems = &.{ Type.toIntern(payload.to), Type.toIntern(payload.from) } }, + } }); + } else { + break :cast_ty try sema.mod.intern(.{ .aggregate = .{ + .ty = sema.mod.safety.panic_cast_ty, + .storage = .{ .elems = &.{ InternPool.Index.void_type, InternPool.Index.void_type } }, + } }); + } + }, + }, + }, + })); + } + + // Old method: + // const decl_index = (try sema.getBuiltinDecl(block, "panic")); + // try sema.ensureDeclAnalyzed(decl_index); + // const fn_val = try mod.declPtr(decl_index).valueOrFail(); + // try sema.declareDependency(.{ .decl_val = decl_index }); + // try mod.ensureFuncBodyAnalysisQueued(fn_val.toIntern()); + // mod.panic_func_index = fn_val.toIntern(); + // + fn prepareRuntimeSafety(sema: *Sema) !void { + if (sema.mod.safety.panic_fn_inst == .none) { + // TODO: Source locations if possible. + const panic_fn_inst: Air.Inst.Ref = try sema.getBuiltin("panic2"); + const callee_ty: Type = sema.typeOf(panic_fn_inst); + const panic_fn_ty: Type = blk: { + const callee_ty_tag: std.builtin.TypeId = callee_ty.zigTypeTag(sema.mod); + if (callee_ty_tag == .Fn) { + break :blk callee_ty; + } + if (callee_ty_tag == .Pointer) { + const ptr_info: InternPool.Key.PtrType = callee_ty.ptrInfo(sema.mod); + if (ptr_info.flags.size == .One and + Type.fromInterned(ptr_info.child).zigTypeTag(sema.mod) == .Fn) + { + break :blk Type.fromInterned(ptr_info.child); + } + } + std.debug.panic("'builtin.panic' must be a function or function pointer, is '{}'", .{ + callee_ty.fmt(sema.mod), + }); + }; + sema.mod.safety.panic_fn_inst = panic_fn_inst; + const func_ty_info: InternPool.Key.FuncType = sema.mod.typeToFunc(panic_fn_ty).?; + if (func_ty_info.return_type != .noreturn_type) { + std.debug.panic("'builtin.panic': expected return type 'noreturn', found '{}'", .{ + Type.fromInterned(func_ty_info.return_type).fmt(sema.mod), + }); + } + const param_types: []InternPool.Index = func_ty_info.param_types.get(&sema.mod.intern_pool); + sema.mod.safety.panic_cause_ty = Type.toIntern(try sema.getBuiltinType("PanicCause")); + sema.mod.safety.panic_id_ty = Type.toIntern(try sema.getBuiltinType("PanicId")); + sema.mod.safety.panic_cast_ty = Type.toIntern(try sema.getBuiltinType("Cast")); + switch (param_types.len) { + 2 => { + // To use this mode properly, the user must declare: + // `fn panic(std.builtin.PanicCause, anytype) noreturn`. + sema.mod.safety.panic_fn_sig = .generic; + sema.mod.safety.panic_data_fn_inst = try sema.getBuiltin("PanicData"); + }, + 1 => { + // To use this mode, the user must declare: + // `fn panic(anytype) noreturn`. + // + // For every panic cause except `message`, the function + // signature is: `fn panic(std.builtin.PanicId) noreturn` + // + // For panic cause `message` the function signature is: + // `fn panic([]const u8) noreturn` + sema.mod.safety.panic_fn_sig = .simple; + }, + else => std.debug.panic("'builtin.panic': expected 2 parameters, found {}", .{ + func_ty_info.param_types.len, + }), + } + } + } + + fn argTyId(param_types: [2]InternPool.Index) u64 { + return @bitCast(param_types); + } + fn cacheOffset(id: std.builtin.PanicId) usize { + comptime var off: comptime_int = 2; + inline for (@typeInfo(std.builtin.PanicId).Enum.fields) |field| { + if (@field(std.builtin.PanicId, field.name) == id) { + return off; + } + off +%= comptime cacheAllowance(@field(std.builtin.PanicId, field.name)); + } + return off; + } + const cache_len = blk: { + var off: usize = 2; + for (@typeInfo(std.builtin.PanicId).Enum.fields) |field| { + off +%= cacheAllowance(@enumFromInt(field.value)); + } + break :blk off; + }; + + fn failBlock(sema: *Sema, parent_block: *Sema.Block) Sema.Block { + return .{ + .parent = parent_block, + .sema = sema, + .src_decl = parent_block.src_decl, + .namespace = parent_block.namespace, + .instructions = .{}, + .inlining = parent_block.inlining, + .is_comptime = false, + }; + } + + // This logic may optimise code generated for arithmetic runtime safety in + // case of bit-shifts. The trade is large and there may be cases where this + // is worse. + // + // This logic requires that all bit-shift RHS operands coerce to either + // `u16` or a vector of `u16`. Insanity? Perhaps, but the type variety of + // bit-shift RHS operands can produce a lot of otherwise identical generic + // `panic` functions. + // + // ATTENTION: This coercion comes at a high cost for vector bit-shifts, and + // questions whether this combination of operands should even + // allow panic data at all. + fn coerceShiftRHSOperand( + sema: *Sema, + block: *Block, + src: std.zig.LazySrcLoc, + rhs: Air.Inst.Ref, + ) !Air.Inst.Ref { + if (!wantRuntimeSafetyPanicData(sema)) { + return .void_value; + } + const rhs_ty: Type = sema.typeOf(rhs); + if (!rhs_ty.isVector(sema.mod)) { + return sema.coerce(block, Type.u16, rhs, src); + } + const vector_ty: Type = try sema.mod.vectorType(.{ + .len = rhs_ty.vectorLen(sema.mod), + .child = Type.toIntern(Type.u16), + }); + return sema.coerce(block, vector_ty, rhs, src); + } + // The basic purpose of this function is to convert `usize` -> `u64`, etc. + // This is done so that operations such as `@intCast(i64, @as(u64, 1))` use + // the same function instance as `@intCast(isize, @as(usize, 01)`. + fn coerceIntegerType(sema: *Sema, int_ty: Type) !Type { + const tag: std.builtin.TypeId = int_ty.zigTypeTag(sema.mod); + if (tag == .Vector) { + return sema.mod.vectorType(.{ + .len = int_ty.vectorLen(sema.mod), + .child = Type.toIntern(try coerceIntegerType(sema, int_ty.scalarType(sema.mod))), + }); + } + if (tag != .Int) { + return int_ty; + } + const int_info: InternPool.Key.IntType = int_ty.intInfo(sema.mod); + switch (int_info.signedness) { + .signed => switch (int_info.bits) { + 8 => return Type.i8, + 16 => return Type.i16, + 32 => return Type.i32, + 64 => return Type.i64, + 128 => return Type.i128, + else => {}, + }, + .unsigned => switch (int_info.bits) { + 8 => return Type.u8, + 16 => return Type.u16, + 32 => return Type.u32, + 64 => return Type.u64, + 128 => return Type.u128, + else => {}, + }, + } + return sema.mod.intType(int_info.signedness, int_info.bits); + } + + /// This optimises addition and subtraction operations. The idea is checking + /// whether the LHS is large or small enough to be overflowed by a + /// `comptime`-known RHS operand. Because the lower and upper bounds may be + /// computed at compile time this method produces less code than the AIR + /// `(add|sub)_with_overflow` + checking the overflow bit. However the + /// advantage is generally not very large, except in functions where inline + /// loops emit safety checks repeatedly. + fn checkSimpleArithmeticOverflowOptimised( + sema: *Sema, + block: *Block, + src: std.zig.LazySrcLoc, + air_tag: Air.Inst.Tag, + resolved_ty: Type, + casted_lhs: Air.Inst.Ref, + casted_rhs: Air.Inst.Ref, + casted_rhs_val: Value, + ) !Air.Inst.Ref { + if (resolved_ty.zigTypeTag(sema.mod) == .Vector) { + return .none; + } + const max_int: Value = try resolved_ty.maxInt(sema.mod, resolved_ty); + const min_int: Value = try resolved_ty.minInt(sema.mod, resolved_ty); + var ov: ?usize = null; + const cmp_op: Air.Inst.Tag, const bound_inst: Air.Inst.Ref = blk: { + switch (air_tag) { + .add => if (try casted_rhs_val.compareAllWithZeroAdvanced(.lt, sema)) { + const casted_rhs_add_1: Value = try sema.intAdd(casted_rhs_val, try sema.mod.intValue(resolved_ty, 1), resolved_ty, &ov); + const lb: Value = try sema.intSub(min_int, casted_rhs_add_1, resolved_ty, &ov); + const cmp_op: Air.Inst.Tag = if (try casted_rhs_add_1.compareAllWithZeroAdvanced(.eq, sema)) .cmp_neq else .cmp_gt; + break :blk .{ cmp_op, Air.internedToRef(Value.toIntern(lb)) }; + } else { + const casted_rhs_sub_1: Value = try sema.intSub(casted_rhs_val, try sema.mod.intValue(resolved_ty, 1), resolved_ty, &ov); + const ub: Value = try sema.intSub(max_int, casted_rhs_sub_1, resolved_ty, &ov); + const cmp_op: Air.Inst.Tag = if (try casted_rhs_sub_1.compareAllWithZeroAdvanced(.eq, sema)) .cmp_neq else .cmp_lt; + break :blk .{ cmp_op, Air.internedToRef(Value.toIntern(ub)) }; + }, + .sub => if (try casted_rhs_val.compareAllWithZeroAdvanced(.lt, sema)) { + const casted_rhs_add_1: Value = try sema.intAdd(casted_rhs_val, try sema.mod.intValue(resolved_ty, 1), resolved_ty, &ov); + const ub: Value = try sema.intAdd(max_int, casted_rhs_add_1, resolved_ty, &ov); + const cmp_op: Air.Inst.Tag = if (try casted_rhs_add_1.compareAllWithZeroAdvanced(.eq, sema)) .cmp_neq else .cmp_lt; + break :blk .{ cmp_op, Air.internedToRef(Value.toIntern(ub)) }; + } else { + const casted_rhs_sub_1: Value = try sema.intSub(casted_rhs_val, try sema.mod.intValue(resolved_ty, 1), resolved_ty, &ov); + const lb: Value = try sema.intAdd(min_int, casted_rhs_sub_1, resolved_ty, &ov); + const cmp_op: Air.Inst.Tag = if (try casted_rhs_sub_1.compareAllWithZeroAdvanced(.eq, sema)) .cmp_neq else .cmp_gt; + break :blk .{ cmp_op, Air.internedToRef(Value.toIntern(lb)) }; + }, + else => return .none, + } + }; + if (ov != null) { + return .none; + } + const ok: Air.Inst.Ref = try block.addBinOp(cmp_op, casted_lhs, bound_inst); + try RuntimeSafety.checkArithmeticOverflow(sema, block, src, resolved_ty, casted_lhs, casted_rhs, ok, air_tag); + return block.addBinOp(air_tag, casted_lhs, casted_rhs); + } + + // This function is used by `returned_noreturn`, `corrupt_switch`, and + // `reached_unreachable`. The `corrupt_switch` panic cause is now reserved + // for unreachable prongs. Most former `corrupt_switch` causes have been + // changed to `cast_to_enum_from_invalid`, however this is still an + // inadequate classification. + fn panicReachedUnreachable( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + comptime id: std.builtin.PanicId, + ) !void { + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, id); + try callPanicFn(sema, parent_block, src, id, &.{ panic_cause_inst, .void_value }, .@"safety check"); + } else _ = try parent_block.addNoOp(.trap); + } + fn panicWithMsg( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + msg_inst: Air.Inst.Ref, + op: Sema.CallOperation, + ) !void { + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .message); + const panic_data_inst: Air.Inst.Ref = try sema.coerce(parent_block, Type.slice_const_u8, msg_inst, src); + try callPanicFn(sema, parent_block, src, .message, &.{ panic_cause_inst, panic_data_inst }, op); + } else _ = try parent_block.addNoOp(.trap); + } + fn panicCastToEnumFromInvalid( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand: Air.Inst.Ref, + ) !void { + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .{ .cast_to_enum_from_invalid = dest_ty }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, parent_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } else _ = try parent_block.addNoOp(.trap); + } + fn panicUnwrappedError( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + err: Air.Inst.Ref, + ) !void { + if (sema.mod.backendSupportsFeature(.panic_fn) and sema.mod.backendSupportsFeature(.panic_unwrap_error)) { + const panic_cause: PanicCause = .unwrapped_error; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) blk: { + const st: Air.Inst.Ref = try sema.getErrorReturnTrace(parent_block); + const panic_data_args: [2]Air.Inst.Ref = .{ st, err }; + break :blk try parent_block.addAggregateInit(try callPanicData(sema, parent_block, src, panic_cause, panic_cause_inst), &panic_data_args); + } else .void_value; + try callPanicFn(sema, parent_block, src, .unwrapped_error, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } else _ = try parent_block.addNoOp(.trap); + } + fn checkAccessNullValue( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .accessed_null_value); + try callPanicFn(sema, &fail_block, src, .accessed_null_value, &.{ panic_cause_inst, .void_value }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkUnwrappedError( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + operand: Air.Inst.Ref, + unwrap_err_tag: Air.Inst.Tag, + is_non_err_tag: Air.Inst.Tag, + ) !void { + const cond: Air.Inst.Ref = try parent_block.addUnOp(is_non_err_tag, operand); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn) and sema.mod.backendSupportsFeature(.panic_unwrap_error)) { + const panic_cause: PanicCause = .unwrapped_error; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) blk: { + const st: Air.Inst.Ref = try sema.getErrorReturnTrace(&fail_block); + const err: Air.Inst.Ref = try fail_block.addTyOp(unwrap_err_tag, Type.anyerror, operand); + const panic_data_args: [2]Air.Inst.Ref = .{ st, err }; + break :blk try fail_block.addAggregateInit(try callPanicData(sema, parent_block, src, panic_cause, panic_cause_inst), &panic_data_args); + } else .void_value; + try callPanicFn(sema, &fail_block, src, .unwrapped_error, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkDivisionByZero( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .divided_by_zero); + try callPanicFn(sema, &fail_block, src, .divided_by_zero, &.{ panic_cause_inst, .void_value }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkAccessOutOfBounds( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_idx: Air.Inst.Ref, + src_len: Air.Inst.Ref, + cmp_op: Air.Inst.Tag, + ) !void { + const cond: Air.Inst.Ref = try parent_block.addBinOp(cmp_op, dest_idx, src_len); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .accessed_out_of_bounds; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [2]Air.Inst.Ref = .{ dest_idx, src_len }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .accessed_out_of_bounds, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkAccessOutOfOrder( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_start: Air.Inst.Ref, + dest_end: Air.Inst.Ref, + ) !void { + const cond: Air.Inst.Ref = try parent_block.addBinOp(.cmp_lte, dest_start, dest_end); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .accessed_out_of_order; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [2]Air.Inst.Ref = .{ dest_start, dest_end }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .accessed_out_of_order, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkAccessOutOfOrderExtra( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_start: Air.Inst.Ref, + dest_end: Air.Inst.Ref, + src_len: Air.Inst.Ref, + cmp_op: Air.Inst.Tag, + ) !void { + const cond: Air.Inst.Ref = try sema.bitCast(parent_block, Type.bool, try parent_block.addBinOp( + .bit_and, + try sema.bitCast(parent_block, Type.u1, try parent_block.addBinOp(.cmp_lte, dest_start, dest_end), src, null), + try sema.bitCast(parent_block, Type.u1, try parent_block.addBinOp(cmp_op, dest_end, src_len), src, null), + ), src, null); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .accessed_out_of_order_extra; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [3]Air.Inst.Ref = .{ dest_start, dest_end, src_len }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .accessed_out_of_order_extra, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkAliasingMemcpyArguments( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_start: Air.Inst.Ref, + dest_finish: Air.Inst.Ref, + src_start: Air.Inst.Ref, + src_finish: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .memcpy_argument_aliasing; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [4]Air.Inst.Ref = .{ + try fail_block.addUnOp(.int_from_ptr, dest_start), try fail_block.addUnOp(.int_from_ptr, dest_finish), + try fail_block.addUnOp(.int_from_ptr, src_start), try fail_block.addUnOp(.int_from_ptr, src_finish), + }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .memcpy_argument_aliasing, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkMismatchedMemcpyArgumentLengths( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_len: Air.Inst.Ref, + src_len: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .mismatched_memcpy_argument_lengths; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .mismatched_memcpy_argument_lengths); + const panic_data_args: [2]Air.Inst.Ref = .{ dest_len, src_len }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .mismatched_memcpy_argument_lengths, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkMismatchedForLoopCaptureLengths( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + loop_len: Air.Inst.Ref, + arg_len: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .mismatched_for_loop_capture_lengths; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .mismatched_for_loop_capture_lengths); + const panic_data_args: [2]Air.Inst.Ref = .{ loop_len, arg_len }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, .mismatched_for_loop_capture_lengths, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkAccessInactiveUnionField( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + active_tag: Air.Inst.Ref, + wanted_tag: Air.Inst.Ref, + ) !void { + const cond: Air.Inst.Ref = try parent_block.addBinOp(.cmp_eq, active_tag, wanted_tag); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .{ .accessed_inactive_field = sema.typeOf(active_tag) }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [2]Air.Inst.Ref = .{ active_tag, wanted_tag }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkMismatchedSentinel( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + elem_ty: Type, + expected: Air.Inst.Ref, + elem_ptr: Air.Inst.Ref, + ) !void { + const found: Air.Inst.Ref = try parent_block.addTyOp(.load, elem_ty, elem_ptr); + const cond: Air.Inst.Ref = try parent_block.addBinOp(.cmp_eq, expected, found); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .{ .mismatched_sentinel = elem_ty }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_args: [2]Air.Inst.Ref = .{ expected, found }; + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &panic_data_args); + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkMismatchedNullTerminator( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + elem_ty: Type, + elem_ptr: Air.Inst.Ref, + ) !void { + const found: Air.Inst.Ref = try parent_block.addTyOp(.load, elem_ty, elem_ptr); + const cond: Air.Inst.Ref = try parent_block.addBinOp(.cmp_eq, .zero_u8, found); + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, .mismatched_null_sentinel); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) found else .void_value; + try callPanicFn(sema, &fail_block, src, .mismatched_null_sentinel, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkShiftAmountOverflow( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + resolved_ty: Type, + shift_amt: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .{ .shift_amt_overflowed = resolved_ty }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = try coerceShiftRHSOperand(sema, &fail_block, src, shift_amt); + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkArithmeticOverflow( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + resolved_ty: Type, + lhs: Air.Inst.Ref, + rhs: Air.Inst.Ref, + cond: Air.Inst.Ref, + tag: Air.Inst.Tag, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const int_ty: Type = try coerceIntegerType(sema, resolved_ty); + const panic_cause: PanicCause = switch (tag) { + .mul => .{ .mul_overflowed = int_ty }, + .add => .{ .add_overflowed = int_ty }, + .sub => .{ .sub_overflowed = int_ty }, + else => .{ .div_overflowed = int_ty }, + .shl_exact => .{ .shl_overflowed = int_ty }, + .shr_exact => .{ .shr_overflowed = int_ty }, + .div_exact => .{ .div_with_remainder = int_ty }, + }; + const casted_rhs: Air.Inst.Ref = switch (tag) { + .shl_exact, .shr_exact => try coerceShiftRHSOperand(sema, &fail_block, src, rhs), + else => rhs, + }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = try preparePanicData(sema, &fail_block, src, panic_cause, panic_cause_inst, &.{ lhs, casted_rhs }); + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkCastToEnumFromInvalid( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const int_ty: Type = Type.intTagType(dest_ty, sema.mod); + const panic_cause: PanicCause = .{ .cast_to_enum_from_invalid = dest_ty }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) try parent_block.addBitCast(int_ty, operand) else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkCastToErrorFromInvalid( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const panic_cause: PanicCause = .{ .cast_to_error_from_invalid = .{ .to = dest_ty, .from = operand_ty } }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + pub fn checkCastToPointerFromInvalid( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const alignment: InternPool.Alignment = try dest_ty.ptrAlignmentAdvanced(sema.mod, sema); + const panic_cause: PanicCause = .{ .cast_to_ptr_from_invalid = alignment }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkCastToIntFromInvalid( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const lhs_ty: Type = try coerceIntegerType(sema, dest_ty); + const panic_cause: PanicCause = .{ .cast_to_int_from_invalid = .{ .to = lhs_ty, .from = operand_ty } }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkCastTruncatedData( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const lhs_ty: Type = try coerceIntegerType(sema, dest_ty); + const rhs_ty: Type = try coerceIntegerType(sema, operand_ty); + const panic_cause: PanicCause = .{ .cast_truncated_data = .{ .to = lhs_ty, .from = rhs_ty } }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } + fn checkCastToUnsignedFromNegative( + sema: *Sema, + parent_block: *Sema.Block, + src: std.zig.LazySrcLoc, + dest_ty: Type, + operand_ty: Type, + operand: Air.Inst.Ref, + cond: Air.Inst.Ref, + ) !void { + var fail_block: Sema.Block = failBlock(sema, parent_block); + defer fail_block.instructions.deinit(sema.gpa); + if (sema.mod.backendSupportsFeature(.panic_fn)) { + const lhs_ty: Type = try coerceIntegerType(sema, dest_ty); + const rhs_ty: Type = try coerceIntegerType(sema, operand_ty); + const panic_cause: PanicCause = .{ .cast_to_unsigned_from_negative = .{ .to = lhs_ty, .from = rhs_ty } }; + const panic_cause_inst: Air.Inst.Ref = try preparePanicCause(sema, panic_cause); + const panic_data_inst: Air.Inst.Ref = if (wantRuntimeSafetyPanicData(sema)) operand else .void_value; + try callPanicFn(sema, &fail_block, src, panic_cause, &.{ panic_cause_inst, panic_data_inst }, .@"safety check"); + } + try addSafetyCheckExtra(sema, parent_block, cond, &fail_block); + } +}; + pub const bitCastVal = @import("Sema/bitcast.zig").bitCast; pub const bitCastSpliceVal = @import("Sema/bitcast.zig").bitCastSplice; diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 9e51417ab623..2b30de661267 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -5546,24 +5546,21 @@ pub const FuncGen = struct { } } - fn buildSimplePanic(fg: *FuncGen, panic_id: Module.PanicId) !void { + fn buildSimplePanic(fg: *FuncGen, intrinsic: Builder.Intrinsic) !void { const o = fg.dg.object; const mod = o.module; - const msg_decl_index = mod.panic_messages[@intFromEnum(panic_id)].unwrap().?; - const msg_decl = mod.declPtr(msg_decl_index); - const msg_len = msg_decl.typeOf(mod).childType(mod).arrayLen(mod); - const msg_ptr = try o.lowerValue(msg_decl.val.toIntern()); - const null_opt_addr_global = try fg.resolveNullOptUsize(); const target = mod.getTarget(); - const llvm_usize = try o.lowerType(Type.usize); - // example: - // call fastcc void @test2.panic( - // ptr @builtin.panic_messages.integer_overflow__anon_987, ; msg.ptr - // i64 16, ; msg.len - // ptr null, ; stack trace - // ptr @2, ; addr (null ?usize) - // ) - const panic_func = mod.funcInfo(mod.panic_func_index); + const panic_id: std.builtin.PanicId = switch (intrinsic) { + .@"sadd.with.overflow", .@"uadd.with.overflow" => .add_overflowed, + .@"ssub.with.overflow", .@"usub.with.overflow" => .sub_overflowed, + .@"smul.with.overflow", .@"umul.with.overflow" => .mul_overflowed, + else => .reached_unreachable, + }; + const tag_value: Value = try mod.enumValueFieldIndex(Type.fromInterned(mod.safety.panic_id_ty), @intFromEnum(panic_id)); + const tag: Builder.Constant = try o.lowerValue(tag_value.toIntern()); + const panic_fn_idx: InternPool.Index = mod.safety.fn_cache[1]; + assert(panic_fn_idx != .none); + const panic_func = mod.funcInfo(panic_fn_idx); const panic_decl = mod.declPtr(panic_func.owner_decl); const fn_info = mod.typeToFunc(panic_decl.typeOf(mod)).?; const panic_global = try o.resolveLlvmFunction(panic_func.owner_decl); @@ -5573,12 +5570,7 @@ pub const FuncGen = struct { .none, panic_global.typeOf(&o.builder), panic_global.toValue(&o.builder), - &.{ - msg_ptr.toValue(), - try o.builder.intValue(llvm_usize, msg_len), - try o.builder.nullValue(.ptr), - null_opt_addr_global.toValue(), - }, + &.{tag.toValue()}, "", ); _ = try fg.wip.@"unreachable"(); @@ -7743,8 +7735,7 @@ pub const FuncGen = struct { const intrinsic = if (scalar_ty.isSignedInt(mod)) signed_intrinsic else unsigned_intrinsic; const llvm_inst_ty = try o.lowerType(inst_ty); - const results = - try fg.wip.callIntrinsic(.normal, .none, intrinsic, &.{llvm_inst_ty}, &.{ lhs, rhs }, ""); + const results = try fg.wip.callIntrinsic(.normal, .none, intrinsic, &.{llvm_inst_ty}, &.{ lhs, rhs }, ""); const overflow_bits = try fg.wip.extractValue(results, &.{1}, ""); const overflow_bits_ty = overflow_bits.typeOfWip(&fg.wip); @@ -7765,8 +7756,7 @@ pub const FuncGen = struct { _ = try fg.wip.brCond(overflow_bit, fail_block, ok_block); fg.wip.cursor = .{ .block = fail_block }; - try fg.buildSimplePanic(.integer_overflow); - + try fg.buildSimplePanic(intrinsic); fg.wip.cursor = .{ .block = ok_block }; return fg.wip.extractValue(results, &.{0}, ""); } diff --git a/src/crash_report.zig b/src/crash_report.zig index 311647f23ff7..4325a7e083e6 100644 --- a/src/crash_report.zig +++ b/src/crash_report.zig @@ -16,7 +16,16 @@ const Decl = Module.Decl; /// To use these crash report diagnostics, publish this panic in your main file /// and add `pub const enable_segfault_handler = false;` to your `std_options`. /// You will also need to call initialize() on startup, preferably as the very first operation in your program. -pub const panic = if (build_options.enable_debug_extensions) compilerPanic else std.builtin.default_panic; +pub const panic = if (build_options.enable_debug_extensions) compilerPanicOld else std.debug.panicImpl; +pub const panic2 = if (build_options.enable_debug_extensions) compilerPanicSimple else std.builtin.panicImpl; + +pub fn compilerPanicOld(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, maybe_ret_addr: ?usize) noreturn { + PanicSwitch.preDispatch(); + @setCold(true); + const ret_addr = maybe_ret_addr orelse @returnAddress(); + const stack_ctx: StackContext = .{ .current = .{ .ret_addr = ret_addr } }; + PanicSwitch.dispatch(error_return_trace, stack_ctx, msg); +} /// Install signal handlers to identify crashes and report diagnostics. pub fn initialize() void { @@ -144,14 +153,28 @@ fn writeFullyQualifiedDeclWithFile(mod: *Module, decl: *Decl, writer: anytype) ! try decl.renderFullyQualifiedDebugName(mod, writer); } -pub fn compilerPanic(msg: []const u8, error_return_trace: ?*std.builtin.StackTrace, maybe_ret_addr: ?usize) noreturn { +pub fn compilerPanic(comptime panic_cause: std.builtin.PanicCause, data: anytype) noreturn { PanicSwitch.preDispatch(); @setCold(true); - const ret_addr = maybe_ret_addr orelse @returnAddress(); + const ret_addr = @returnAddress(); + const error_return_trace: ?std.builtin.StackTrace = + if (panic_cause != .unwrapped_error) null else data.st; + const msg: []const u8 = + if (panic_cause != .message) @tagName(panic_cause) else data; const stack_ctx: StackContext = .{ .current = .{ .ret_addr = ret_addr } }; PanicSwitch.dispatch(error_return_trace, stack_ctx, msg); } +pub fn compilerPanicSimple(id: anytype) noreturn { + PanicSwitch.preDispatch(); + @setCold(true); + PanicSwitch.dispatch( + null, + .{ .current = .{ .ret_addr = @returnAddress() } }, + if (@TypeOf(id) == std.builtin.PanicId) @tagName(id) else id, + ); +} + /// Attaches a global SIGSEGV handler pub fn attachSegfaultHandler() void { if (!debug.have_segfault_handling_support) { diff --git a/src/main.zig b/src/main.zig index 099ceb27f90c..a351af20ea13 100644 --- a/src/main.zig +++ b/src/main.zig @@ -4609,7 +4609,9 @@ fn cmdTranslateC(comp: *Compilation, arena: Allocator, fancy_output: ?*Compilati try man.addDepFilePost(zig_cache_tmp_dir, dep_basename); // Just to save disk space, we delete the file because it is never needed again. zig_cache_tmp_dir.deleteFile(dep_basename) catch |err| { - warn("failed to delete '{s}': {s}", .{ dep_file_path, @errorName(err) }); + if (err != error.FileNotFound) { + warn("failed to delete '{s}': {s}", .{ dep_file_path, @errorName(err) }); + } }; } diff --git a/src/target.zig b/src/target.zig index 6af301e00101..4f29d1bf30c7 100644 --- a/src/target.zig +++ b/src/target.zig @@ -527,7 +527,7 @@ pub fn backendSupportsFeature( feature: Feature, ) bool { return switch (feature) { - .panic_fn => ofmt == .c or use_llvm or cpu_arch == .x86_64 or cpu_arch == .riscv64, + .panic_fn => ofmt == .c or use_llvm or cpu_arch == .x86_64, .panic_unwrap_error => ofmt == .c or use_llvm, .safety_check_formatted => ofmt == .c or use_llvm, .error_return_trace => use_llvm, diff --git a/src/type.zig b/src/type.zig index 5dad904ca060..8c1aa04c40e0 100644 --- a/src/type.zig +++ b/src/type.zig @@ -75,6 +75,39 @@ pub const Type = struct { }; } + pub fn allowsSentinel(ty: Type, mod: *const Module) bool { + return switch (ty.zigTypeTag(mod)) { + .Int, + .Float, + .ComptimeFloat, + .ComptimeInt, + .Bool, + .Type, + .Void, + .ErrorSet, + .Fn, + .Opaque, + .AnyFrame, + .Enum, + .EnumLiteral, + => true, + + .Vector, + .NoReturn, + .Array, + .Struct, + .Undefined, + .Null, + .ErrorUnion, + .Union, + .Frame, + => false, + + .Pointer => !ty.isSlice(mod), + .Optional => allowsSentinel(ty.optionalChild(mod), mod), + }; + } + /// If it is a function pointer, returns the function type. Otherwise returns null. pub fn castPtrToFn(ty: Type, mod: *const Module) ?Type { if (ty.zigTypeTag(mod) != .Pointer) return null; diff --git a/test/behavior.zig b/test/behavior.zig index ea8ea713aca9..8c63cc2371fd 100644 --- a/test/behavior.zig +++ b/test/behavior.zig @@ -80,6 +80,7 @@ test { _ = @import("behavior/shuffle.zig"); _ = @import("behavior/sizeof_and_typeof.zig"); _ = @import("behavior/slice.zig"); + _ = @import("behavior/slice2.zig"); _ = @import("behavior/slice_sentinel_comptime.zig"); _ = @import("behavior/src.zig"); _ = @import("behavior/string_literals.zig"); diff --git a/test/behavior/comptime_memory.zig b/test/behavior/comptime_memory.zig index 597ba62dd490..4abef3f8b9b5 100644 --- a/test/behavior/comptime_memory.zig +++ b/test/behavior/comptime_memory.zig @@ -45,7 +45,7 @@ test "type pun signed and unsigned as array pointer with pointer arithemtic" { comptime { var x: [11]u32 = undefined; const y = @as([*]i32, @ptrCast(&x[10])) - 10; - const z: *[15]i32 = y[0..15]; + const z: *[11]i32 = y[0..11]; z[10] = -1; try testing.expectEqual(@as(u32, 0xFFFFFFFF), x[10]); } diff --git a/test/behavior/slice.zig b/test/behavior/slice.zig index 437d248127d1..9f632ae4e460 100644 --- a/test/behavior/slice.zig +++ b/test/behavior/slice.zig @@ -389,11 +389,11 @@ test "slice multi-pointer without end" { var array = [5:0]u8{ 1, 2, 3, 4, 5 }; const pointer: [*:0]u8 = &array; - comptime assert(@TypeOf(pointer[1..]) == [*:0]u8); + comptime assert(@TypeOf(pointer[1..]) == [*]u8); comptime assert(@TypeOf(pointer[1.. :0]) == [*:0]u8); const slice = pointer[1..]; - comptime assert(@TypeOf(slice) == [*:0]u8); + comptime assert(@TypeOf(slice) == [*]u8); try expect(slice[0] == 2); try expect(slice[1] == 3); } diff --git a/test/behavior/slice2.zig b/test/behavior/slice2.zig new file mode 100644 index 000000000000..a761bd235fea --- /dev/null +++ b/test/behavior/slice2.zig @@ -0,0 +1,3199 @@ +var dest_end: usize = 0; +var dest_start: usize = 0; +var dest_len: usize = 0; +var src_mem0: [2]u8 = undefined; +fn fn0() void { + const src_ptr0: *[2]u8 = src_mem0[0..2]; + vs(*[2]u8, @as(*[2]u8, src_ptr0), 0, src_ptr0[0..]); + ve(*[2]u8, @as(*[2]u8, src_ptr0), 0, 2, src_ptr0[0..2]); + ve(*[1]u8, @as(*[2]u8, src_ptr0), 0, 1, src_ptr0[0..1]); + dest_end = 1; + ve([]u8, @as(*[2]u8, src_ptr0), 0, dest_end, src_ptr0[0..dest_end]); + vl(*[2]u8, @as(*[2]u8, src_ptr0), 0, 2, src_ptr0[0..][0..2]); + vl(*[1]u8, @as(*[2]u8, src_ptr0), 0, 1, src_ptr0[0..][0..1]); + dest_len = 1; + vl([]u8, @as(*[2]u8, src_ptr0), 0, dest_len, src_ptr0[0..][0..dest_len]); + vs(*[1]u8, @as(*[2]u8, src_ptr0), 1, src_ptr0[1..]); + ve(*[1]u8, @as(*[2]u8, src_ptr0), 1, 2, src_ptr0[1..2]); + ve(*[0]u8, @as(*[2]u8, src_ptr0), 1, 1, src_ptr0[1..1]); + ve([]u8, @as(*[2]u8, src_ptr0), 1, dest_end, src_ptr0[1..dest_end]); + vl(*[1]u8, @as(*[2]u8, src_ptr0), 1, 1, src_ptr0[1..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr0), 1, dest_len, src_ptr0[1..][0..dest_len]); +} +var src_mem1: [3]u8 = undefined; +fn fn1() void { + const src_ptr1: *[3]u8 = src_mem1[0..3]; + vs(*[3]u8, @as(*[3]u8, src_ptr1), 0, src_ptr1[0..]); + const src_ptr2: *[3]u8 = src_mem1[0..3]; + ve(*[2]u8, @as(*[3]u8, src_ptr2), 0, 2, src_ptr2[0..2]); + ve(*[3]u8, @as(*[3]u8, src_ptr2), 0, 3, src_ptr2[0..3]); + ve(*[1]u8, @as(*[3]u8, src_ptr2), 0, 1, src_ptr2[0..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr2), 0, dest_end, src_ptr2[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr2), 0, dest_end, src_ptr2[0..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr2), 0, 2, src_ptr2[0..][0..2]); + vl(*[3]u8, @as(*[3]u8, src_ptr2), 0, 3, src_ptr2[0..][0..3]); + vl(*[1]u8, @as(*[3]u8, src_ptr2), 0, 1, src_ptr2[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[3]u8, src_ptr2), 0, dest_len, src_ptr2[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[3]u8, src_ptr2), 0, dest_len, src_ptr2[0..][0..dest_len]); + vs(*[2]u8, @as(*[3]u8, src_ptr2), 1, src_ptr2[1..]); + ve(*[1]u8, @as(*[3]u8, src_ptr2), 1, 2, src_ptr2[1..2]); + ve(*[2]u8, @as(*[3]u8, src_ptr2), 1, 3, src_ptr2[1..3]); + ve(*[0]u8, @as(*[3]u8, src_ptr2), 1, 1, src_ptr2[1..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr2), 1, dest_end, src_ptr2[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr2), 1, dest_end, src_ptr2[1..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr2), 1, 2, src_ptr2[1..][0..2]); + vl(*[1]u8, @as(*[3]u8, src_ptr2), 1, 1, src_ptr2[1..][0..1]); + vl([]u8, @as(*[3]u8, src_ptr2), 1, dest_len, src_ptr2[1..][0..dest_len]); + vs(*[0]u8, @as(*[3]u8, src_ptr2), 3, src_ptr2[3..]); + ve(*[0]u8, @as(*[3]u8, src_ptr2), 3, 3, src_ptr2[3..3]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr2), 3, dest_end, src_ptr2[3..dest_end]); + vs(*[3]u8, @as(*[3]u8, src_ptr2), 0, src_ptr2[0..]); +} +var src_mem2: [1]u8 = undefined; +fn fn2() void { + const src_ptr3: *[1]u8 = src_mem2[0..1]; + vs(*[1]u8, @as(*[1]u8, src_ptr3), 0, src_ptr3[0..]); + const src_ptr4: *[1]u8 = src_mem2[0..1]; + ve(*[1]u8, @as(*[1]u8, src_ptr4), 0, 1, src_ptr4[0..1]); + dest_end = 1; + ve([]u8, @as(*[1]u8, src_ptr4), 0, dest_end, src_ptr4[0..dest_end]); + vl(*[1]u8, @as(*[1]u8, src_ptr4), 0, 1, src_ptr4[0..][0..1]); + vl([]u8, @as(*[1]u8, src_ptr4), 0, dest_len, src_ptr4[0..][0..dest_len]); + vs(*[0]u8, @as(*[1]u8, src_ptr4), 1, src_ptr4[1..]); + ve(*[0]u8, @as(*[1]u8, src_ptr4), 1, 1, src_ptr4[1..1]); + ve([]u8, @as(*[1]u8, src_ptr4), 1, dest_end, src_ptr4[1..dest_end]); + vs(*[1]u8, @as(*[1]u8, src_ptr4), 0, src_ptr4[0..]); + var src_mem3: [2]u8 = undefined; + var src_ptr5: *[2]u8 = src_mem3[0..2]; + vs(*[2]u8, @as(*[2]u8, src_ptr5), 0, src_ptr5[0..]); + ve(*[2]u8, @as(*[2]u8, src_ptr5), 0, 2, src_ptr5[0..2]); + ve(*[1]u8, @as(*[2]u8, src_ptr5), 0, 1, src_ptr5[0..1]); + ve([]u8, @as(*[2]u8, src_ptr5), 0, dest_end, src_ptr5[0..dest_end]); + vl(*[2]u8, @as(*[2]u8, src_ptr5), 0, 2, src_ptr5[0..][0..2]); + vl(*[1]u8, @as(*[2]u8, src_ptr5), 0, 1, src_ptr5[0..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr5), 0, dest_len, src_ptr5[0..][0..dest_len]); + vs(*[1]u8, @as(*[2]u8, src_ptr5), 1, src_ptr5[1..]); + ve(*[1]u8, @as(*[2]u8, src_ptr5), 1, 2, src_ptr5[1..2]); + ve(*[0]u8, @as(*[2]u8, src_ptr5), 1, 1, src_ptr5[1..1]); + ve([]u8, @as(*[2]u8, src_ptr5), 1, dest_end, src_ptr5[1..dest_end]); + vl(*[1]u8, @as(*[2]u8, src_ptr5), 1, 1, src_ptr5[1..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr5), 1, dest_len, src_ptr5[1..][0..dest_len]); + var src_mem4: [3]u8 = undefined; + var src_ptr6: *[3]u8 = src_mem4[0..3]; + vs(*[3]u8, @as(*[3]u8, src_ptr6), 0, src_ptr6[0..]); + ve(*[2]u8, @as(*[3]u8, src_ptr6), 0, 2, src_ptr6[0..2]); + ve(*[3]u8, @as(*[3]u8, src_ptr6), 0, 3, src_ptr6[0..3]); + ve(*[1]u8, @as(*[3]u8, src_ptr6), 0, 1, src_ptr6[0..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr6), 0, dest_end, src_ptr6[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr6), 0, dest_end, src_ptr6[0..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr6), 0, 2, src_ptr6[0..][0..2]); + vl(*[3]u8, @as(*[3]u8, src_ptr6), 0, 3, src_ptr6[0..][0..3]); + vl(*[1]u8, @as(*[3]u8, src_ptr6), 0, 1, src_ptr6[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[3]u8, src_ptr6), 0, dest_len, src_ptr6[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[3]u8, src_ptr6), 0, dest_len, src_ptr6[0..][0..dest_len]); + vs(*[2]u8, @as(*[3]u8, src_ptr6), 1, src_ptr6[1..]); + ve(*[1]u8, @as(*[3]u8, src_ptr6), 1, 2, src_ptr6[1..2]); + ve(*[2]u8, @as(*[3]u8, src_ptr6), 1, 3, src_ptr6[1..3]); + ve(*[0]u8, @as(*[3]u8, src_ptr6), 1, 1, src_ptr6[1..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr6), 1, dest_end, src_ptr6[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr6), 1, dest_end, src_ptr6[1..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr6), 1, 2, src_ptr6[1..][0..2]); + vl(*[1]u8, @as(*[3]u8, src_ptr6), 1, 1, src_ptr6[1..][0..1]); + vl([]u8, @as(*[3]u8, src_ptr6), 1, dest_len, src_ptr6[1..][0..dest_len]); + vs(*[0]u8, @as(*[3]u8, src_ptr6), 3, src_ptr6[3..]); + ve(*[0]u8, @as(*[3]u8, src_ptr6), 3, 3, src_ptr6[3..3]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr6), 3, dest_end, src_ptr6[3..dest_end]); + var src_mem5: [1]u8 = undefined; + var src_ptr7: *[1]u8 = src_mem5[0..1]; + vs(*[1]u8, @as(*[1]u8, src_ptr7), 0, src_ptr7[0..]); + ve(*[1]u8, @as(*[1]u8, src_ptr7), 0, 1, src_ptr7[0..1]); + dest_end = 1; + ve([]u8, @as(*[1]u8, src_ptr7), 0, dest_end, src_ptr7[0..dest_end]); + vl(*[1]u8, @as(*[1]u8, src_ptr7), 0, 1, src_ptr7[0..][0..1]); + vl([]u8, @as(*[1]u8, src_ptr7), 0, dest_len, src_ptr7[0..][0..dest_len]); + vs(*[0]u8, @as(*[1]u8, src_ptr7), 1, src_ptr7[1..]); + ve(*[0]u8, @as(*[1]u8, src_ptr7), 1, 1, src_ptr7[1..1]); + ve([]u8, @as(*[1]u8, src_ptr7), 1, dest_end, src_ptr7[1..dest_end]); + const src_ptr8: []u8 = src_mem0[0..2]; + vs(*[2]u8, @as([]u8, src_ptr8), 0, src_ptr8[0..]); + ve(*[2]u8, @as([]u8, src_ptr8), 0, 2, src_ptr8[0..2]); + ve(*[1]u8, @as([]u8, src_ptr8), 0, 1, src_ptr8[0..1]); + ve([]u8, @as([]u8, src_ptr8), 0, dest_end, src_ptr8[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr8), 0, 2, src_ptr8[0..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr8), 0, 1, src_ptr8[0..][0..1]); + vl([]u8, @as([]u8, src_ptr8), 0, dest_len, src_ptr8[0..][0..dest_len]); + vs(*[1]u8, @as([]u8, src_ptr8), 1, src_ptr8[1..]); + ve(*[1]u8, @as([]u8, src_ptr8), 1, 2, src_ptr8[1..2]); + ve(*[0]u8, @as([]u8, src_ptr8), 1, 1, src_ptr8[1..1]); + ve([]u8, @as([]u8, src_ptr8), 1, dest_end, src_ptr8[1..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr8), 1, 1, src_ptr8[1..][0..1]); + vl([]u8, @as([]u8, src_ptr8), 1, dest_len, src_ptr8[1..][0..dest_len]); + const src_ptr9: []u8 = src_mem1[0..3]; + vs(*[3]u8, @as([]u8, src_ptr9), 0, src_ptr9[0..]); + ve(*[2]u8, @as([]u8, src_ptr9), 0, 2, src_ptr9[0..2]); + ve(*[3]u8, @as([]u8, src_ptr9), 0, 3, src_ptr9[0..3]); + ve(*[1]u8, @as([]u8, src_ptr9), 0, 1, src_ptr9[0..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr9), 0, dest_end, src_ptr9[0..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr9), 0, dest_end, src_ptr9[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr9), 0, 2, src_ptr9[0..][0..2]); + vl(*[3]u8, @as([]u8, src_ptr9), 0, 3, src_ptr9[0..][0..3]); + vl(*[1]u8, @as([]u8, src_ptr9), 0, 1, src_ptr9[0..][0..1]); + dest_len = 3; + vl([]u8, @as([]u8, src_ptr9), 0, dest_len, src_ptr9[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([]u8, src_ptr9), 0, dest_len, src_ptr9[0..][0..dest_len]); + vs(*[2]u8, @as([]u8, src_ptr9), 1, src_ptr9[1..]); + ve(*[1]u8, @as([]u8, src_ptr9), 1, 2, src_ptr9[1..2]); + ve(*[2]u8, @as([]u8, src_ptr9), 1, 3, src_ptr9[1..3]); + ve(*[0]u8, @as([]u8, src_ptr9), 1, 1, src_ptr9[1..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr9), 1, dest_end, src_ptr9[1..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr9), 1, dest_end, src_ptr9[1..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr9), 1, 2, src_ptr9[1..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr9), 1, 1, src_ptr9[1..][0..1]); + vl([]u8, @as([]u8, src_ptr9), 1, dest_len, src_ptr9[1..][0..dest_len]); + vs(*[0]u8, @as([]u8, src_ptr9), 3, src_ptr9[3..]); + ve(*[0]u8, @as([]u8, src_ptr9), 3, 3, src_ptr9[3..3]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr9), 3, dest_end, src_ptr9[3..dest_end]); + const src_ptr10: []u8 = src_mem2[0..1]; + vs(*[1]u8, @as([]u8, src_ptr10), 0, src_ptr10[0..]); + ve(*[1]u8, @as([]u8, src_ptr10), 0, 1, src_ptr10[0..1]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr10), 0, dest_end, src_ptr10[0..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr10), 0, 1, src_ptr10[0..][0..1]); + vl([]u8, @as([]u8, src_ptr10), 0, dest_len, src_ptr10[0..][0..dest_len]); + vs(*[0]u8, @as([]u8, src_ptr10), 1, src_ptr10[1..]); + ve(*[0]u8, @as([]u8, src_ptr10), 1, 1, src_ptr10[1..1]); + ve([]u8, @as([]u8, src_ptr10), 1, dest_end, src_ptr10[1..dest_end]); + var src_ptr11: []u8 = src_mem3[0..2]; + vs([]u8, @as([]u8, src_ptr11), 0, src_ptr11[0..]); + ve(*[2]u8, @as([]u8, src_ptr11), 0, 2, src_ptr11[0..2]); + ve(*[1]u8, @as([]u8, src_ptr11), 0, 1, src_ptr11[0..1]); + ve([]u8, @as([]u8, src_ptr11), 0, dest_end, src_ptr11[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr11), 0, 2, src_ptr11[0..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr11), 0, 1, src_ptr11[0..][0..1]); + vl([]u8, @as([]u8, src_ptr11), 0, dest_len, src_ptr11[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr11), 1, src_ptr11[1..]); + ve(*[1]u8, @as([]u8, src_ptr11), 1, 2, src_ptr11[1..2]); + ve(*[0]u8, @as([]u8, src_ptr11), 1, 1, src_ptr11[1..1]); + ve([]u8, @as([]u8, src_ptr11), 1, dest_end, src_ptr11[1..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr11), 1, 1, src_ptr11[1..][0..1]); + vl([]u8, @as([]u8, src_ptr11), 1, dest_len, src_ptr11[1..][0..dest_len]); + var src_ptr12: []u8 = src_mem4[0..3]; + vs([]u8, @as([]u8, src_ptr12), 0, src_ptr12[0..]); + ve(*[2]u8, @as([]u8, src_ptr12), 0, 2, src_ptr12[0..2]); + ve(*[3]u8, @as([]u8, src_ptr12), 0, 3, src_ptr12[0..3]); + ve(*[1]u8, @as([]u8, src_ptr12), 0, 1, src_ptr12[0..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr12), 0, dest_end, src_ptr12[0..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr12), 0, dest_end, src_ptr12[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr12), 0, 2, src_ptr12[0..][0..2]); + vl(*[3]u8, @as([]u8, src_ptr12), 0, 3, src_ptr12[0..][0..3]); + vl(*[1]u8, @as([]u8, src_ptr12), 0, 1, src_ptr12[0..][0..1]); + dest_len = 3; + vl([]u8, @as([]u8, src_ptr12), 0, dest_len, src_ptr12[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([]u8, src_ptr12), 0, dest_len, src_ptr12[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr12), 1, src_ptr12[1..]); + ve(*[1]u8, @as([]u8, src_ptr12), 1, 2, src_ptr12[1..2]); + ve(*[2]u8, @as([]u8, src_ptr12), 1, 3, src_ptr12[1..3]); + ve(*[0]u8, @as([]u8, src_ptr12), 1, 1, src_ptr12[1..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr12), 1, dest_end, src_ptr12[1..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr12), 1, dest_end, src_ptr12[1..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr12), 1, 2, src_ptr12[1..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr12), 1, 1, src_ptr12[1..][0..1]); + vl([]u8, @as([]u8, src_ptr12), 1, dest_len, src_ptr12[1..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr12), 3, src_ptr12[3..]); + ve(*[0]u8, @as([]u8, src_ptr12), 3, 3, src_ptr12[3..3]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr12), 3, dest_end, src_ptr12[3..dest_end]); + var src_ptr13: []u8 = src_mem5[0..1]; + vs([]u8, @as([]u8, src_ptr13), 0, src_ptr13[0..]); + ve(*[1]u8, @as([]u8, src_ptr13), 0, 1, src_ptr13[0..1]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr13), 0, dest_end, src_ptr13[0..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr13), 0, 1, src_ptr13[0..][0..1]); + vl([]u8, @as([]u8, src_ptr13), 0, dest_len, src_ptr13[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr13), 1, src_ptr13[1..]); + ve(*[0]u8, @as([]u8, src_ptr13), 1, 1, src_ptr13[1..1]); + ve([]u8, @as([]u8, src_ptr13), 1, dest_end, src_ptr13[1..dest_end]); + const src_ptr14: [*]u8 = @ptrCast(&src_mem0); + vs([*]u8, @as([*]u8, src_ptr14), 0, src_ptr14[0..]); + ve(*[2]u8, @as([*]u8, src_ptr14), 0, 2, src_ptr14[0..2]); + ve(*[1]u8, @as([*]u8, src_ptr14), 0, 1, src_ptr14[0..1]); + ve([]u8, @as([*]u8, src_ptr14), 0, dest_end, src_ptr14[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr14), 0, 2, src_ptr14[0..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr14), 0, 1, src_ptr14[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr14), 0, dest_len, src_ptr14[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr14), 1, src_ptr14[1..]); + ve(*[1]u8, @as([*]u8, src_ptr14), 1, 2, src_ptr14[1..2]); + ve(*[0]u8, @as([*]u8, src_ptr14), 1, 1, src_ptr14[1..1]); + ve([]u8, @as([*]u8, src_ptr14), 1, dest_end, src_ptr14[1..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr14), 1, 1, src_ptr14[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr14), 1, dest_len, src_ptr14[1..][0..dest_len]); + const src_ptr15: [*]u8 = @ptrCast(&src_mem1); + vs([*]u8, @as([*]u8, src_ptr15), 0, src_ptr15[0..]); + ve(*[2]u8, @as([*]u8, src_ptr15), 0, 2, src_ptr15[0..2]); + ve(*[3]u8, @as([*]u8, src_ptr15), 0, 3, src_ptr15[0..3]); + ve(*[1]u8, @as([*]u8, src_ptr15), 0, 1, src_ptr15[0..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr15), 0, dest_end, src_ptr15[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr15), 0, dest_end, src_ptr15[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr15), 0, 2, src_ptr15[0..][0..2]); + vl(*[3]u8, @as([*]u8, src_ptr15), 0, 3, src_ptr15[0..][0..3]); + vl(*[1]u8, @as([*]u8, src_ptr15), 0, 1, src_ptr15[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*]u8, src_ptr15), 0, dest_len, src_ptr15[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*]u8, src_ptr15), 0, dest_len, src_ptr15[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr15), 1, src_ptr15[1..]); + ve(*[1]u8, @as([*]u8, src_ptr15), 1, 2, src_ptr15[1..2]); + ve(*[2]u8, @as([*]u8, src_ptr15), 1, 3, src_ptr15[1..3]); + ve(*[0]u8, @as([*]u8, src_ptr15), 1, 1, src_ptr15[1..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr15), 1, dest_end, src_ptr15[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr15), 1, dest_end, src_ptr15[1..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr15), 1, 2, src_ptr15[1..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr15), 1, 1, src_ptr15[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr15), 1, dest_len, src_ptr15[1..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr15), 3, src_ptr15[3..]); + ve(*[0]u8, @as([*]u8, src_ptr15), 3, 3, src_ptr15[3..3]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr15), 3, dest_end, src_ptr15[3..dest_end]); + const src_ptr16: [*]u8 = @ptrCast(&src_mem2); + vs([*]u8, @as([*]u8, src_ptr16), 0, src_ptr16[0..]); + ve(*[1]u8, @as([*]u8, src_ptr16), 0, 1, src_ptr16[0..1]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr16), 0, dest_end, src_ptr16[0..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr16), 0, 1, src_ptr16[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr16), 0, dest_len, src_ptr16[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr16), 1, src_ptr16[1..]); + ve(*[0]u8, @as([*]u8, src_ptr16), 1, 1, src_ptr16[1..1]); + ve([]u8, @as([*]u8, src_ptr16), 1, dest_end, src_ptr16[1..dest_end]); + var src_ptr17: [*]u8 = @ptrCast(&src_mem3); + vs([*]u8, @as([*]u8, src_ptr17), 0, src_ptr17[0..]); + ve(*[2]u8, @as([*]u8, src_ptr17), 0, 2, src_ptr17[0..2]); + ve(*[1]u8, @as([*]u8, src_ptr17), 0, 1, src_ptr17[0..1]); + ve([]u8, @as([*]u8, src_ptr17), 0, dest_end, src_ptr17[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr17), 0, 2, src_ptr17[0..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr17), 0, 1, src_ptr17[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr17), 0, dest_len, src_ptr17[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr17), 1, src_ptr17[1..]); + ve(*[1]u8, @as([*]u8, src_ptr17), 1, 2, src_ptr17[1..2]); + ve(*[0]u8, @as([*]u8, src_ptr17), 1, 1, src_ptr17[1..1]); + ve([]u8, @as([*]u8, src_ptr17), 1, dest_end, src_ptr17[1..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr17), 1, 1, src_ptr17[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr17), 1, dest_len, src_ptr17[1..][0..dest_len]); + var src_ptr18: [*]u8 = @ptrCast(&src_mem4); + vs([*]u8, @as([*]u8, src_ptr18), 0, src_ptr18[0..]); + ve(*[2]u8, @as([*]u8, src_ptr18), 0, 2, src_ptr18[0..2]); + ve(*[3]u8, @as([*]u8, src_ptr18), 0, 3, src_ptr18[0..3]); + ve(*[1]u8, @as([*]u8, src_ptr18), 0, 1, src_ptr18[0..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr18), 0, dest_end, src_ptr18[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr18), 0, dest_end, src_ptr18[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr18), 0, 2, src_ptr18[0..][0..2]); + vl(*[3]u8, @as([*]u8, src_ptr18), 0, 3, src_ptr18[0..][0..3]); + vl(*[1]u8, @as([*]u8, src_ptr18), 0, 1, src_ptr18[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*]u8, src_ptr18), 0, dest_len, src_ptr18[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*]u8, src_ptr18), 0, dest_len, src_ptr18[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr18), 1, src_ptr18[1..]); + ve(*[1]u8, @as([*]u8, src_ptr18), 1, 2, src_ptr18[1..2]); + ve(*[2]u8, @as([*]u8, src_ptr18), 1, 3, src_ptr18[1..3]); + ve(*[0]u8, @as([*]u8, src_ptr18), 1, 1, src_ptr18[1..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr18), 1, dest_end, src_ptr18[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr18), 1, dest_end, src_ptr18[1..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr18), 1, 2, src_ptr18[1..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr18), 1, 1, src_ptr18[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr18), 1, dest_len, src_ptr18[1..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr18), 3, src_ptr18[3..]); + ve(*[0]u8, @as([*]u8, src_ptr18), 3, 3, src_ptr18[3..3]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr18), 3, dest_end, src_ptr18[3..dest_end]); + var src_ptr19: [*]u8 = @ptrCast(&src_mem5); + vs([*]u8, @as([*]u8, src_ptr19), 0, src_ptr19[0..]); + ve(*[1]u8, @as([*]u8, src_ptr19), 0, 1, src_ptr19[0..1]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr19), 0, dest_end, src_ptr19[0..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr19), 0, 1, src_ptr19[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr19), 0, dest_len, src_ptr19[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr19), 1, src_ptr19[1..]); + ve(*[0]u8, @as([*]u8, src_ptr19), 1, 1, src_ptr19[1..1]); + ve([]u8, @as([*]u8, src_ptr19), 1, dest_end, src_ptr19[1..dest_end]); + const src_ptr20: [*c]u8 = @ptrCast(&src_mem0); + vs([*c]u8, @as([*c]u8, src_ptr20), 0, src_ptr20[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr20), 0, 2, src_ptr20[0..2]); + ve(*[1]u8, @as([*c]u8, src_ptr20), 0, 1, src_ptr20[0..1]); + ve([]u8, @as([*c]u8, src_ptr20), 0, dest_end, src_ptr20[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr20), 0, 2, src_ptr20[0..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr20), 0, 1, src_ptr20[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr20), 0, dest_len, src_ptr20[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr20), 1, src_ptr20[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr20), 1, 2, src_ptr20[1..2]); + ve(*[0]u8, @as([*c]u8, src_ptr20), 1, 1, src_ptr20[1..1]); + ve([]u8, @as([*c]u8, src_ptr20), 1, dest_end, src_ptr20[1..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr20), 1, 1, src_ptr20[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr20), 1, dest_len, src_ptr20[1..][0..dest_len]); + const src_ptr21: [*c]u8 = @ptrCast(&src_mem1); + vs([*c]u8, @as([*c]u8, src_ptr21), 0, src_ptr21[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr21), 0, 2, src_ptr21[0..2]); + ve(*[3]u8, @as([*c]u8, src_ptr21), 0, 3, src_ptr21[0..3]); + ve(*[1]u8, @as([*c]u8, src_ptr21), 0, 1, src_ptr21[0..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr21), 0, dest_end, src_ptr21[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr21), 0, dest_end, src_ptr21[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr21), 0, 2, src_ptr21[0..][0..2]); + vl(*[3]u8, @as([*c]u8, src_ptr21), 0, 3, src_ptr21[0..][0..3]); + vl(*[1]u8, @as([*c]u8, src_ptr21), 0, 1, src_ptr21[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*c]u8, src_ptr21), 0, dest_len, src_ptr21[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*c]u8, src_ptr21), 0, dest_len, src_ptr21[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr21), 1, src_ptr21[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr21), 1, 2, src_ptr21[1..2]); + ve(*[2]u8, @as([*c]u8, src_ptr21), 1, 3, src_ptr21[1..3]); + ve(*[0]u8, @as([*c]u8, src_ptr21), 1, 1, src_ptr21[1..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr21), 1, dest_end, src_ptr21[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr21), 1, dest_end, src_ptr21[1..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr21), 1, 2, src_ptr21[1..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr21), 1, 1, src_ptr21[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr21), 1, dest_len, src_ptr21[1..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr21), 3, src_ptr21[3..]); + ve(*[0]u8, @as([*c]u8, src_ptr21), 3, 3, src_ptr21[3..3]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr21), 3, dest_end, src_ptr21[3..dest_end]); + const src_ptr22: [*c]u8 = @ptrCast(&src_mem2); + vs([*c]u8, @as([*c]u8, src_ptr22), 0, src_ptr22[0..]); + ve(*[1]u8, @as([*c]u8, src_ptr22), 0, 1, src_ptr22[0..1]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr22), 0, dest_end, src_ptr22[0..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr22), 0, 1, src_ptr22[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr22), 0, dest_len, src_ptr22[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr22), 1, src_ptr22[1..]); + ve(*[0]u8, @as([*c]u8, src_ptr22), 1, 1, src_ptr22[1..1]); + ve([]u8, @as([*c]u8, src_ptr22), 1, dest_end, src_ptr22[1..dest_end]); + var src_ptr23: [*c]u8 = @ptrCast(&src_mem3); + vs([*c]u8, @as([*c]u8, src_ptr23), 0, src_ptr23[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr23), 0, 2, src_ptr23[0..2]); + ve(*[1]u8, @as([*c]u8, src_ptr23), 0, 1, src_ptr23[0..1]); + ve([]u8, @as([*c]u8, src_ptr23), 0, dest_end, src_ptr23[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr23), 0, 2, src_ptr23[0..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr23), 0, 1, src_ptr23[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr23), 0, dest_len, src_ptr23[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr23), 1, src_ptr23[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr23), 1, 2, src_ptr23[1..2]); + ve(*[0]u8, @as([*c]u8, src_ptr23), 1, 1, src_ptr23[1..1]); + ve([]u8, @as([*c]u8, src_ptr23), 1, dest_end, src_ptr23[1..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr23), 1, 1, src_ptr23[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr23), 1, dest_len, src_ptr23[1..][0..dest_len]); + var src_ptr24: [*c]u8 = @ptrCast(&src_mem4); + vs([*c]u8, @as([*c]u8, src_ptr24), 0, src_ptr24[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr24), 0, 2, src_ptr24[0..2]); + ve(*[3]u8, @as([*c]u8, src_ptr24), 0, 3, src_ptr24[0..3]); + ve(*[1]u8, @as([*c]u8, src_ptr24), 0, 1, src_ptr24[0..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr24), 0, dest_end, src_ptr24[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr24), 0, dest_end, src_ptr24[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr24), 0, 2, src_ptr24[0..][0..2]); + vl(*[3]u8, @as([*c]u8, src_ptr24), 0, 3, src_ptr24[0..][0..3]); + vl(*[1]u8, @as([*c]u8, src_ptr24), 0, 1, src_ptr24[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*c]u8, src_ptr24), 0, dest_len, src_ptr24[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*c]u8, src_ptr24), 0, dest_len, src_ptr24[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr24), 1, src_ptr24[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr24), 1, 2, src_ptr24[1..2]); + ve(*[2]u8, @as([*c]u8, src_ptr24), 1, 3, src_ptr24[1..3]); + ve(*[0]u8, @as([*c]u8, src_ptr24), 1, 1, src_ptr24[1..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr24), 1, dest_end, src_ptr24[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr24), 1, dest_end, src_ptr24[1..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr24), 1, 2, src_ptr24[1..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr24), 1, 1, src_ptr24[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr24), 1, dest_len, src_ptr24[1..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr24), 3, src_ptr24[3..]); + ve(*[0]u8, @as([*c]u8, src_ptr24), 3, 3, src_ptr24[3..3]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr24), 3, dest_end, src_ptr24[3..dest_end]); + var src_ptr25: [*c]u8 = @ptrCast(&src_mem5); + vs([*c]u8, @as([*c]u8, src_ptr25), 0, src_ptr25[0..]); + ve(*[1]u8, @as([*c]u8, src_ptr25), 0, 1, src_ptr25[0..1]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr25), 0, dest_end, src_ptr25[0..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr25), 0, 1, src_ptr25[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr25), 0, dest_len, src_ptr25[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr25), 1, src_ptr25[1..]); + ve(*[0]u8, @as([*c]u8, src_ptr25), 1, 1, src_ptr25[1..1]); + ve([]u8, @as([*c]u8, src_ptr25), 1, dest_end, src_ptr25[1..dest_end]); +} +var src_mem6: [2]u8 = .{ 0, 0 }; +fn fn3() void { + const src_ptr26: *[2]u8 = src_mem6[0..2]; + vs(*[2]u8, @as(*[2]u8, src_ptr26), 0, src_ptr26[0..]); + const src_ptr27: *[2]u8 = src_mem6[0..2]; + ve(*[2]u8, @as(*[2]u8, src_ptr27), 0, 2, src_ptr27[0..2]); + ve(*[1]u8, @as(*[2]u8, src_ptr27), 0, 1, src_ptr27[0..1]); + ve([]u8, @as(*[2]u8, src_ptr27), 0, dest_end, src_ptr27[0..dest_end]); + vl(*[2]u8, @as(*[2]u8, src_ptr27), 0, 2, src_ptr27[0..][0..2]); + vl(*[1]u8, @as(*[2]u8, src_ptr27), 0, 1, src_ptr27[0..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr27), 0, dest_len, src_ptr27[0..][0..dest_len]); + vs(*[1]u8, @as(*[2]u8, src_ptr27), 1, src_ptr27[1..]); + ve(*[1]u8, @as(*[2]u8, src_ptr27), 1, 2, src_ptr27[1..2]); + ve(*[0]u8, @as(*[2]u8, src_ptr27), 1, 1, src_ptr27[1..1]); + ve([]u8, @as(*[2]u8, src_ptr27), 1, dest_end, src_ptr27[1..dest_end]); + vl(*[1]u8, @as(*[2]u8, src_ptr27), 1, 1, src_ptr27[1..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr27), 1, dest_len, src_ptr27[1..][0..dest_len]); +} +var src_mem7: [2]u8 = .{ 0, 0 }; +fn fn4() void { + const src_ptr28: *[1:0]u8 = src_mem7[0..1 :0]; + vs(*[1:0]u8, @as(*[1:0]u8, src_ptr28), 0, src_ptr28[0..]); + const src_ptr29: *[1:0]u8 = src_mem7[0..1 :0]; + ve(*[2]u8, @as(*[1:0]u8, src_ptr29), 0, 2, src_ptr29[0..2]); + ve(*[1:0]u8, @as(*[1:0]u8, src_ptr29), 0, 1, src_ptr29[0..1]); + ve([]u8, @as(*[1:0]u8, src_ptr29), 0, dest_end, src_ptr29[0..dest_end]); + vl(*[2]u8, @as(*[1:0]u8, src_ptr29), 0, 2, src_ptr29[0..][0..2]); + vl(*[1:0]u8, @as(*[1:0]u8, src_ptr29), 0, 1, src_ptr29[0..][0..1]); + vl([]u8, @as(*[1:0]u8, src_ptr29), 0, dest_len, src_ptr29[0..][0..dest_len]); + vs(*[0:0]u8, @as(*[1:0]u8, src_ptr29), 1, src_ptr29[1..]); + ve(*[1]u8, @as(*[1:0]u8, src_ptr29), 1, 2, src_ptr29[1..2]); + ve(*[0:0]u8, @as(*[1:0]u8, src_ptr29), 1, 1, src_ptr29[1..1]); + ve([]u8, @as(*[1:0]u8, src_ptr29), 1, dest_end, src_ptr29[1..dest_end]); + vl(*[1]u8, @as(*[1:0]u8, src_ptr29), 1, 1, src_ptr29[1..][0..1]); + vl([]u8, @as(*[1:0]u8, src_ptr29), 1, dest_len, src_ptr29[1..][0..dest_len]); + const src_ptr30: *[2]u8 = src_mem6[0..2]; + vs(*[2]u8, @as(*[2]u8, src_ptr30), 0, src_ptr30[0..]); + ve(*[2]u8, @as(*[2]u8, src_ptr30), 0, 2, src_ptr30[0..2]); + ve(*[1]u8, @as(*[2]u8, src_ptr30), 0, 1, src_ptr30[0..1]); + ve([]u8, @as(*[2]u8, src_ptr30), 0, dest_end, src_ptr30[0..dest_end]); + vl(*[2]u8, @as(*[2]u8, src_ptr30), 0, 2, src_ptr30[0..][0..2]); + vl(*[1]u8, @as(*[2]u8, src_ptr30), 0, 1, src_ptr30[0..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr30), 0, dest_len, src_ptr30[0..][0..dest_len]); + vs(*[1]u8, @as(*[2]u8, src_ptr30), 1, src_ptr30[1..]); + ve(*[1]u8, @as(*[2]u8, src_ptr30), 1, 2, src_ptr30[1..2]); + ve(*[0]u8, @as(*[2]u8, src_ptr30), 1, 1, src_ptr30[1..1]); + ve([]u8, @as(*[2]u8, src_ptr30), 1, dest_end, src_ptr30[1..dest_end]); + vl(*[1]u8, @as(*[2]u8, src_ptr30), 1, 1, src_ptr30[1..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr30), 1, dest_len, src_ptr30[1..][0..dest_len]); + vs(*[1:0]u8, @as(*[1:0]u8, src_ptr29), 0, src_ptr29[0..]); +} +var src_mem8: [3]u8 = .{ 0, 0, 0 }; +fn fn5() void { + const src_ptr31: *[3]u8 = src_mem8[0..3]; + vs(*[3]u8, @as(*[3]u8, src_ptr31), 0, src_ptr31[0..]); + const src_ptr32: *[3]u8 = src_mem8[0..3]; + ve(*[2]u8, @as(*[3]u8, src_ptr32), 0, 2, src_ptr32[0..2]); + ve(*[3]u8, @as(*[3]u8, src_ptr32), 0, 3, src_ptr32[0..3]); + ve(*[1]u8, @as(*[3]u8, src_ptr32), 0, 1, src_ptr32[0..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr32), 0, dest_end, src_ptr32[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr32), 0, dest_end, src_ptr32[0..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr32), 0, 2, src_ptr32[0..][0..2]); + vl(*[3]u8, @as(*[3]u8, src_ptr32), 0, 3, src_ptr32[0..][0..3]); + vl(*[1]u8, @as(*[3]u8, src_ptr32), 0, 1, src_ptr32[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[3]u8, src_ptr32), 0, dest_len, src_ptr32[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[3]u8, src_ptr32), 0, dest_len, src_ptr32[0..][0..dest_len]); + vs(*[2]u8, @as(*[3]u8, src_ptr32), 1, src_ptr32[1..]); + ve(*[1]u8, @as(*[3]u8, src_ptr32), 1, 2, src_ptr32[1..2]); + ve(*[2]u8, @as(*[3]u8, src_ptr32), 1, 3, src_ptr32[1..3]); + ve(*[0]u8, @as(*[3]u8, src_ptr32), 1, 1, src_ptr32[1..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr32), 1, dest_end, src_ptr32[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr32), 1, dest_end, src_ptr32[1..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr32), 1, 2, src_ptr32[1..][0..2]); + vl(*[1]u8, @as(*[3]u8, src_ptr32), 1, 1, src_ptr32[1..][0..1]); + vl([]u8, @as(*[3]u8, src_ptr32), 1, dest_len, src_ptr32[1..][0..dest_len]); + vs(*[0]u8, @as(*[3]u8, src_ptr32), 3, src_ptr32[3..]); + ve(*[0]u8, @as(*[3]u8, src_ptr32), 3, 3, src_ptr32[3..3]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr32), 3, dest_end, src_ptr32[3..dest_end]); +} +var src_mem9: [3]u8 = .{ 0, 0, 0 }; +fn fn6() void { + const src_ptr33: *[2:0]u8 = src_mem9[0..2 :0]; + vs(*[2:0]u8, @as(*[2:0]u8, src_ptr33), 0, src_ptr33[0..]); + const src_ptr34: *[2:0]u8 = src_mem9[0..2 :0]; + ve(*[2:0]u8, @as(*[2:0]u8, src_ptr34), 0, 2, src_ptr34[0..2]); + ve(*[3]u8, @as(*[2:0]u8, src_ptr34), 0, 3, src_ptr34[0..3]); + ve(*[1]u8, @as(*[2:0]u8, src_ptr34), 0, 1, src_ptr34[0..1]); + ve([]u8, @as(*[2:0]u8, src_ptr34), 0, dest_end, src_ptr34[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[2:0]u8, src_ptr34), 0, dest_end, src_ptr34[0..dest_end]); + vl(*[2:0]u8, @as(*[2:0]u8, src_ptr34), 0, 2, src_ptr34[0..][0..2]); + vl(*[3]u8, @as(*[2:0]u8, src_ptr34), 0, 3, src_ptr34[0..][0..3]); + vl(*[1]u8, @as(*[2:0]u8, src_ptr34), 0, 1, src_ptr34[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[2:0]u8, src_ptr34), 0, dest_len, src_ptr34[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[2:0]u8, src_ptr34), 0, dest_len, src_ptr34[0..][0..dest_len]); + vs(*[1:0]u8, @as(*[2:0]u8, src_ptr34), 1, src_ptr34[1..]); + ve(*[1:0]u8, @as(*[2:0]u8, src_ptr34), 1, 2, src_ptr34[1..2]); + ve(*[2]u8, @as(*[2:0]u8, src_ptr34), 1, 3, src_ptr34[1..3]); + ve(*[0]u8, @as(*[2:0]u8, src_ptr34), 1, 1, src_ptr34[1..1]); + dest_end = 3; + ve([]u8, @as(*[2:0]u8, src_ptr34), 1, dest_end, src_ptr34[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[2:0]u8, src_ptr34), 1, dest_end, src_ptr34[1..dest_end]); + vl(*[2]u8, @as(*[2:0]u8, src_ptr34), 1, 2, src_ptr34[1..][0..2]); + vl(*[1:0]u8, @as(*[2:0]u8, src_ptr34), 1, 1, src_ptr34[1..][0..1]); + vl([]u8, @as(*[2:0]u8, src_ptr34), 1, dest_len, src_ptr34[1..][0..dest_len]); + ve(*[0]u8, @as(*[2:0]u8, src_ptr34), 3, 3, src_ptr34[3..3]); + dest_end = 3; + ve([]u8, @as(*[2:0]u8, src_ptr34), 3, dest_end, src_ptr34[3..dest_end]); + const src_ptr35: *[3]u8 = src_mem8[0..3]; + vs(*[3]u8, @as(*[3]u8, src_ptr35), 0, src_ptr35[0..]); + ve(*[2]u8, @as(*[3]u8, src_ptr35), 0, 2, src_ptr35[0..2]); + ve(*[3]u8, @as(*[3]u8, src_ptr35), 0, 3, src_ptr35[0..3]); + ve(*[1]u8, @as(*[3]u8, src_ptr35), 0, 1, src_ptr35[0..1]); + ve([]u8, @as(*[3]u8, src_ptr35), 0, dest_end, src_ptr35[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr35), 0, dest_end, src_ptr35[0..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr35), 0, 2, src_ptr35[0..][0..2]); + vl(*[3]u8, @as(*[3]u8, src_ptr35), 0, 3, src_ptr35[0..][0..3]); + vl(*[1]u8, @as(*[3]u8, src_ptr35), 0, 1, src_ptr35[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[3]u8, src_ptr35), 0, dest_len, src_ptr35[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[3]u8, src_ptr35), 0, dest_len, src_ptr35[0..][0..dest_len]); + vs(*[2]u8, @as(*[3]u8, src_ptr35), 1, src_ptr35[1..]); + ve(*[1]u8, @as(*[3]u8, src_ptr35), 1, 2, src_ptr35[1..2]); + ve(*[2]u8, @as(*[3]u8, src_ptr35), 1, 3, src_ptr35[1..3]); + ve(*[0]u8, @as(*[3]u8, src_ptr35), 1, 1, src_ptr35[1..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr35), 1, dest_end, src_ptr35[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr35), 1, dest_end, src_ptr35[1..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr35), 1, 2, src_ptr35[1..][0..2]); + vl(*[1]u8, @as(*[3]u8, src_ptr35), 1, 1, src_ptr35[1..][0..1]); + vl([]u8, @as(*[3]u8, src_ptr35), 1, dest_len, src_ptr35[1..][0..dest_len]); + vs(*[0]u8, @as(*[3]u8, src_ptr35), 3, src_ptr35[3..]); + ve(*[0]u8, @as(*[3]u8, src_ptr35), 3, 3, src_ptr35[3..3]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr35), 3, dest_end, src_ptr35[3..dest_end]); + vs(*[2:0]u8, @as(*[2:0]u8, src_ptr34), 0, src_ptr34[0..]); +} +var src_mem10: [1]u8 = .{0}; +fn fn7() void { + const src_ptr36: *[1]u8 = src_mem10[0..1]; + vs(*[1]u8, @as(*[1]u8, src_ptr36), 0, src_ptr36[0..]); + const src_ptr37: *[1]u8 = src_mem10[0..1]; + ve(*[1]u8, @as(*[1]u8, src_ptr37), 0, 1, src_ptr37[0..1]); + dest_end = 1; + ve([]u8, @as(*[1]u8, src_ptr37), 0, dest_end, src_ptr37[0..dest_end]); + vl(*[1]u8, @as(*[1]u8, src_ptr37), 0, 1, src_ptr37[0..][0..1]); + vl([]u8, @as(*[1]u8, src_ptr37), 0, dest_len, src_ptr37[0..][0..dest_len]); + vs(*[0]u8, @as(*[1]u8, src_ptr37), 1, src_ptr37[1..]); + ve(*[0]u8, @as(*[1]u8, src_ptr37), 1, 1, src_ptr37[1..1]); + ve([]u8, @as(*[1]u8, src_ptr37), 1, dest_end, src_ptr37[1..dest_end]); +} +var src_mem11: [1]u8 = .{0}; +fn fn8() void { + const src_ptr38: *[0:0]u8 = src_mem11[0..0 :0]; + vs(*[0:0]u8, @as(*[0:0]u8, src_ptr38), 0, src_ptr38[0..]); + const src_ptr39: *[0:0]u8 = src_mem11[0..0 :0]; + ve(*[1]u8, @as(*[0:0]u8, src_ptr39), 0, 1, src_ptr39[0..1]); + ve([]u8, @as(*[0:0]u8, src_ptr39), 0, dest_end, src_ptr39[0..dest_end]); + vl(*[1]u8, @as(*[0:0]u8, src_ptr39), 0, 1, src_ptr39[0..][0..1]); + vl([]u8, @as(*[0:0]u8, src_ptr39), 0, dest_len, src_ptr39[0..][0..dest_len]); + ve(*[0]u8, @as(*[0:0]u8, src_ptr39), 1, 1, src_ptr39[1..1]); + ve([]u8, @as(*[0:0]u8, src_ptr39), 1, dest_end, src_ptr39[1..dest_end]); + const src_ptr40: *[1]u8 = src_mem10[0..1]; + vs(*[1]u8, @as(*[1]u8, src_ptr40), 0, src_ptr40[0..]); + ve(*[1]u8, @as(*[1]u8, src_ptr40), 0, 1, src_ptr40[0..1]); + ve([]u8, @as(*[1]u8, src_ptr40), 0, dest_end, src_ptr40[0..dest_end]); + vl(*[1]u8, @as(*[1]u8, src_ptr40), 0, 1, src_ptr40[0..][0..1]); + vl([]u8, @as(*[1]u8, src_ptr40), 0, dest_len, src_ptr40[0..][0..dest_len]); + vs(*[0]u8, @as(*[1]u8, src_ptr40), 1, src_ptr40[1..]); + ve(*[0]u8, @as(*[1]u8, src_ptr40), 1, 1, src_ptr40[1..1]); + ve([]u8, @as(*[1]u8, src_ptr40), 1, dest_end, src_ptr40[1..dest_end]); + vs(*[0:0]u8, @as(*[0:0]u8, src_ptr39), 0, src_ptr39[0..]); + var src_mem12: [2]u8 = .{ 0, 0 }; + var src_ptr41: *[2]u8 = src_mem12[0..2]; + vs(*[2]u8, @as(*[2]u8, src_ptr41), 0, src_ptr41[0..]); + ve(*[2]u8, @as(*[2]u8, src_ptr41), 0, 2, src_ptr41[0..2]); + ve(*[1]u8, @as(*[2]u8, src_ptr41), 0, 1, src_ptr41[0..1]); + ve([]u8, @as(*[2]u8, src_ptr41), 0, dest_end, src_ptr41[0..dest_end]); + vl(*[2]u8, @as(*[2]u8, src_ptr41), 0, 2, src_ptr41[0..][0..2]); + vl(*[1]u8, @as(*[2]u8, src_ptr41), 0, 1, src_ptr41[0..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr41), 0, dest_len, src_ptr41[0..][0..dest_len]); + vs(*[1]u8, @as(*[2]u8, src_ptr41), 1, src_ptr41[1..]); + ve(*[1]u8, @as(*[2]u8, src_ptr41), 1, 2, src_ptr41[1..2]); + ve(*[0]u8, @as(*[2]u8, src_ptr41), 1, 1, src_ptr41[1..1]); + ve([]u8, @as(*[2]u8, src_ptr41), 1, dest_end, src_ptr41[1..dest_end]); + vl(*[1]u8, @as(*[2]u8, src_ptr41), 1, 1, src_ptr41[1..][0..1]); + vl([]u8, @as(*[2]u8, src_ptr41), 1, dest_len, src_ptr41[1..][0..dest_len]); + var src_mem13: [2]u8 = .{ 0, 0 }; + var src_ptr42: *[1:0]u8 = src_mem13[0..1 :0]; + vs(*[1:0]u8, @as(*[1:0]u8, src_ptr42), 0, src_ptr42[0..]); + ve(*[2]u8, @as(*[1:0]u8, src_ptr42), 0, 2, src_ptr42[0..2]); + ve(*[1:0]u8, @as(*[1:0]u8, src_ptr42), 0, 1, src_ptr42[0..1]); + ve([]u8, @as(*[1:0]u8, src_ptr42), 0, dest_end, src_ptr42[0..dest_end]); + vl(*[2]u8, @as(*[1:0]u8, src_ptr42), 0, 2, src_ptr42[0..][0..2]); + vl(*[1:0]u8, @as(*[1:0]u8, src_ptr42), 0, 1, src_ptr42[0..][0..1]); + vl([]u8, @as(*[1:0]u8, src_ptr42), 0, dest_len, src_ptr42[0..][0..dest_len]); + vs(*[0:0]u8, @as(*[1:0]u8, src_ptr42), 1, src_ptr42[1..]); + ve(*[1]u8, @as(*[1:0]u8, src_ptr42), 1, 2, src_ptr42[1..2]); + ve(*[0:0]u8, @as(*[1:0]u8, src_ptr42), 1, 1, src_ptr42[1..1]); + ve([]u8, @as(*[1:0]u8, src_ptr42), 1, dest_end, src_ptr42[1..dest_end]); + vl(*[1]u8, @as(*[1:0]u8, src_ptr42), 1, 1, src_ptr42[1..][0..1]); + vl([]u8, @as(*[1:0]u8, src_ptr42), 1, dest_len, src_ptr42[1..][0..dest_len]); + var src_mem14: [3]u8 = .{ 0, 0, 0 }; + var src_ptr43: *[3]u8 = src_mem14[0..3]; + vs(*[3]u8, @as(*[3]u8, src_ptr43), 0, src_ptr43[0..]); + ve(*[2]u8, @as(*[3]u8, src_ptr43), 0, 2, src_ptr43[0..2]); + ve(*[3]u8, @as(*[3]u8, src_ptr43), 0, 3, src_ptr43[0..3]); + ve(*[1]u8, @as(*[3]u8, src_ptr43), 0, 1, src_ptr43[0..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr43), 0, dest_end, src_ptr43[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr43), 0, dest_end, src_ptr43[0..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr43), 0, 2, src_ptr43[0..][0..2]); + vl(*[3]u8, @as(*[3]u8, src_ptr43), 0, 3, src_ptr43[0..][0..3]); + vl(*[1]u8, @as(*[3]u8, src_ptr43), 0, 1, src_ptr43[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[3]u8, src_ptr43), 0, dest_len, src_ptr43[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[3]u8, src_ptr43), 0, dest_len, src_ptr43[0..][0..dest_len]); + vs(*[2]u8, @as(*[3]u8, src_ptr43), 1, src_ptr43[1..]); + ve(*[1]u8, @as(*[3]u8, src_ptr43), 1, 2, src_ptr43[1..2]); + ve(*[2]u8, @as(*[3]u8, src_ptr43), 1, 3, src_ptr43[1..3]); + ve(*[0]u8, @as(*[3]u8, src_ptr43), 1, 1, src_ptr43[1..1]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr43), 1, dest_end, src_ptr43[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[3]u8, src_ptr43), 1, dest_end, src_ptr43[1..dest_end]); + vl(*[2]u8, @as(*[3]u8, src_ptr43), 1, 2, src_ptr43[1..][0..2]); + vl(*[1]u8, @as(*[3]u8, src_ptr43), 1, 1, src_ptr43[1..][0..1]); + vl([]u8, @as(*[3]u8, src_ptr43), 1, dest_len, src_ptr43[1..][0..dest_len]); + vs(*[0]u8, @as(*[3]u8, src_ptr43), 3, src_ptr43[3..]); + ve(*[0]u8, @as(*[3]u8, src_ptr43), 3, 3, src_ptr43[3..3]); + dest_end = 3; + ve([]u8, @as(*[3]u8, src_ptr43), 3, dest_end, src_ptr43[3..dest_end]); + var src_mem15: [3]u8 = .{ 0, 0, 0 }; + var src_ptr44: *[2:0]u8 = src_mem15[0..2 :0]; + vs(*[2:0]u8, @as(*[2:0]u8, src_ptr44), 0, src_ptr44[0..]); + ve(*[2:0]u8, @as(*[2:0]u8, src_ptr44), 0, 2, src_ptr44[0..2]); + ve(*[3]u8, @as(*[2:0]u8, src_ptr44), 0, 3, src_ptr44[0..3]); + ve(*[1]u8, @as(*[2:0]u8, src_ptr44), 0, 1, src_ptr44[0..1]); + ve([]u8, @as(*[2:0]u8, src_ptr44), 0, dest_end, src_ptr44[0..dest_end]); + dest_end = 1; + ve([]u8, @as(*[2:0]u8, src_ptr44), 0, dest_end, src_ptr44[0..dest_end]); + vl(*[2:0]u8, @as(*[2:0]u8, src_ptr44), 0, 2, src_ptr44[0..][0..2]); + vl(*[3]u8, @as(*[2:0]u8, src_ptr44), 0, 3, src_ptr44[0..][0..3]); + vl(*[1]u8, @as(*[2:0]u8, src_ptr44), 0, 1, src_ptr44[0..][0..1]); + dest_len = 3; + vl([]u8, @as(*[2:0]u8, src_ptr44), 0, dest_len, src_ptr44[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as(*[2:0]u8, src_ptr44), 0, dest_len, src_ptr44[0..][0..dest_len]); + vs(*[1:0]u8, @as(*[2:0]u8, src_ptr44), 1, src_ptr44[1..]); + ve(*[1:0]u8, @as(*[2:0]u8, src_ptr44), 1, 2, src_ptr44[1..2]); + ve(*[2]u8, @as(*[2:0]u8, src_ptr44), 1, 3, src_ptr44[1..3]); + ve(*[0]u8, @as(*[2:0]u8, src_ptr44), 1, 1, src_ptr44[1..1]); + dest_end = 3; + ve([]u8, @as(*[2:0]u8, src_ptr44), 1, dest_end, src_ptr44[1..dest_end]); + dest_end = 1; + ve([]u8, @as(*[2:0]u8, src_ptr44), 1, dest_end, src_ptr44[1..dest_end]); + vl(*[2]u8, @as(*[2:0]u8, src_ptr44), 1, 2, src_ptr44[1..][0..2]); + vl(*[1:0]u8, @as(*[2:0]u8, src_ptr44), 1, 1, src_ptr44[1..][0..1]); + vl([]u8, @as(*[2:0]u8, src_ptr44), 1, dest_len, src_ptr44[1..][0..dest_len]); + ve(*[0]u8, @as(*[2:0]u8, src_ptr44), 3, 3, src_ptr44[3..3]); + dest_end = 3; + ve([]u8, @as(*[2:0]u8, src_ptr44), 3, dest_end, src_ptr44[3..dest_end]); + var src_mem16: [1]u8 = .{0}; + var src_ptr45: *[1]u8 = src_mem16[0..1]; + vs(*[1]u8, @as(*[1]u8, src_ptr45), 0, src_ptr45[0..]); + ve(*[1]u8, @as(*[1]u8, src_ptr45), 0, 1, src_ptr45[0..1]); + dest_end = 1; + ve([]u8, @as(*[1]u8, src_ptr45), 0, dest_end, src_ptr45[0..dest_end]); + vl(*[1]u8, @as(*[1]u8, src_ptr45), 0, 1, src_ptr45[0..][0..1]); + vl([]u8, @as(*[1]u8, src_ptr45), 0, dest_len, src_ptr45[0..][0..dest_len]); + vs(*[0]u8, @as(*[1]u8, src_ptr45), 1, src_ptr45[1..]); + ve(*[0]u8, @as(*[1]u8, src_ptr45), 1, 1, src_ptr45[1..1]); + ve([]u8, @as(*[1]u8, src_ptr45), 1, dest_end, src_ptr45[1..dest_end]); + var src_mem17: [1]u8 = .{0}; + var src_ptr46: *[0:0]u8 = src_mem17[0..0 :0]; + vs(*[0:0]u8, @as(*[0:0]u8, src_ptr46), 0, src_ptr46[0..]); + ve(*[1]u8, @as(*[0:0]u8, src_ptr46), 0, 1, src_ptr46[0..1]); + ve([]u8, @as(*[0:0]u8, src_ptr46), 0, dest_end, src_ptr46[0..dest_end]); + vl(*[1]u8, @as(*[0:0]u8, src_ptr46), 0, 1, src_ptr46[0..][0..1]); + vl([]u8, @as(*[0:0]u8, src_ptr46), 0, dest_len, src_ptr46[0..][0..dest_len]); + ve(*[0]u8, @as(*[0:0]u8, src_ptr46), 1, 1, src_ptr46[1..1]); + ve([]u8, @as(*[0:0]u8, src_ptr46), 1, dest_end, src_ptr46[1..dest_end]); + const src_ptr47: []u8 = src_mem6[0..2]; + vs(*[2]u8, @as([]u8, src_ptr47), 0, src_ptr47[0..]); + ve(*[2]u8, @as([]u8, src_ptr47), 0, 2, src_ptr47[0..2]); + ve(*[1]u8, @as([]u8, src_ptr47), 0, 1, src_ptr47[0..1]); + ve([]u8, @as([]u8, src_ptr47), 0, dest_end, src_ptr47[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr47), 0, 2, src_ptr47[0..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr47), 0, 1, src_ptr47[0..][0..1]); + vl([]u8, @as([]u8, src_ptr47), 0, dest_len, src_ptr47[0..][0..dest_len]); + vs(*[1]u8, @as([]u8, src_ptr47), 1, src_ptr47[1..]); + ve(*[1]u8, @as([]u8, src_ptr47), 1, 2, src_ptr47[1..2]); + ve(*[0]u8, @as([]u8, src_ptr47), 1, 1, src_ptr47[1..1]); + ve([]u8, @as([]u8, src_ptr47), 1, dest_end, src_ptr47[1..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr47), 1, 1, src_ptr47[1..][0..1]); + vl([]u8, @as([]u8, src_ptr47), 1, dest_len, src_ptr47[1..][0..dest_len]); + const src_ptr48: [:0]u8 = src_mem7[0..1 :0]; + vs(*[1:0]u8, @as([:0]u8, src_ptr48), 0, src_ptr48[0..]); + ve(*[2]u8, @as([:0]u8, src_ptr48), 0, 2, src_ptr48[0..2]); + ve(*[1:0]u8, @as([:0]u8, src_ptr48), 0, 1, src_ptr48[0..1]); + ve([]u8, @as([:0]u8, src_ptr48), 0, dest_end, src_ptr48[0..dest_end]); + vl(*[2]u8, @as([:0]u8, src_ptr48), 0, 2, src_ptr48[0..][0..2]); + vl(*[1:0]u8, @as([:0]u8, src_ptr48), 0, 1, src_ptr48[0..][0..1]); + vl([]u8, @as([:0]u8, src_ptr48), 0, dest_len, src_ptr48[0..][0..dest_len]); + vs(*[0:0]u8, @as([:0]u8, src_ptr48), 1, src_ptr48[1..]); + ve(*[1]u8, @as([:0]u8, src_ptr48), 1, 2, src_ptr48[1..2]); + ve(*[0:0]u8, @as([:0]u8, src_ptr48), 1, 1, src_ptr48[1..1]); + ve([]u8, @as([:0]u8, src_ptr48), 1, dest_end, src_ptr48[1..dest_end]); + vl(*[1]u8, @as([:0]u8, src_ptr48), 1, 1, src_ptr48[1..][0..1]); + vl([]u8, @as([:0]u8, src_ptr48), 1, dest_len, src_ptr48[1..][0..dest_len]); + const src_ptr49: []u8 = src_mem8[0..3]; + vs(*[3]u8, @as([]u8, src_ptr49), 0, src_ptr49[0..]); + ve(*[2]u8, @as([]u8, src_ptr49), 0, 2, src_ptr49[0..2]); + ve(*[3]u8, @as([]u8, src_ptr49), 0, 3, src_ptr49[0..3]); + ve(*[1]u8, @as([]u8, src_ptr49), 0, 1, src_ptr49[0..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr49), 0, dest_end, src_ptr49[0..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr49), 0, dest_end, src_ptr49[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr49), 0, 2, src_ptr49[0..][0..2]); + vl(*[3]u8, @as([]u8, src_ptr49), 0, 3, src_ptr49[0..][0..3]); + vl(*[1]u8, @as([]u8, src_ptr49), 0, 1, src_ptr49[0..][0..1]); + dest_len = 3; + vl([]u8, @as([]u8, src_ptr49), 0, dest_len, src_ptr49[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([]u8, src_ptr49), 0, dest_len, src_ptr49[0..][0..dest_len]); + vs(*[2]u8, @as([]u8, src_ptr49), 1, src_ptr49[1..]); + ve(*[1]u8, @as([]u8, src_ptr49), 1, 2, src_ptr49[1..2]); + ve(*[2]u8, @as([]u8, src_ptr49), 1, 3, src_ptr49[1..3]); + ve(*[0]u8, @as([]u8, src_ptr49), 1, 1, src_ptr49[1..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr49), 1, dest_end, src_ptr49[1..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr49), 1, dest_end, src_ptr49[1..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr49), 1, 2, src_ptr49[1..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr49), 1, 1, src_ptr49[1..][0..1]); + vl([]u8, @as([]u8, src_ptr49), 1, dest_len, src_ptr49[1..][0..dest_len]); + vs(*[0]u8, @as([]u8, src_ptr49), 3, src_ptr49[3..]); + ve(*[0]u8, @as([]u8, src_ptr49), 3, 3, src_ptr49[3..3]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr49), 3, dest_end, src_ptr49[3..dest_end]); + const src_ptr50: [:0]u8 = src_mem9[0..2 :0]; + vs(*[2:0]u8, @as([:0]u8, src_ptr50), 0, src_ptr50[0..]); + ve(*[2:0]u8, @as([:0]u8, src_ptr50), 0, 2, src_ptr50[0..2]); + ve(*[3]u8, @as([:0]u8, src_ptr50), 0, 3, src_ptr50[0..3]); + ve(*[1]u8, @as([:0]u8, src_ptr50), 0, 1, src_ptr50[0..1]); + ve([]u8, @as([:0]u8, src_ptr50), 0, dest_end, src_ptr50[0..dest_end]); + dest_end = 1; + ve([]u8, @as([:0]u8, src_ptr50), 0, dest_end, src_ptr50[0..dest_end]); + vl(*[2:0]u8, @as([:0]u8, src_ptr50), 0, 2, src_ptr50[0..][0..2]); + vl(*[3]u8, @as([:0]u8, src_ptr50), 0, 3, src_ptr50[0..][0..3]); + vl(*[1]u8, @as([:0]u8, src_ptr50), 0, 1, src_ptr50[0..][0..1]); + dest_len = 3; + vl([]u8, @as([:0]u8, src_ptr50), 0, dest_len, src_ptr50[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([:0]u8, src_ptr50), 0, dest_len, src_ptr50[0..][0..dest_len]); + vs(*[1:0]u8, @as([:0]u8, src_ptr50), 1, src_ptr50[1..]); + ve(*[1:0]u8, @as([:0]u8, src_ptr50), 1, 2, src_ptr50[1..2]); + ve(*[2]u8, @as([:0]u8, src_ptr50), 1, 3, src_ptr50[1..3]); + ve(*[0]u8, @as([:0]u8, src_ptr50), 1, 1, src_ptr50[1..1]); + dest_end = 3; + ve([]u8, @as([:0]u8, src_ptr50), 1, dest_end, src_ptr50[1..dest_end]); + dest_end = 1; + ve([]u8, @as([:0]u8, src_ptr50), 1, dest_end, src_ptr50[1..dest_end]); + vl(*[2]u8, @as([:0]u8, src_ptr50), 1, 2, src_ptr50[1..][0..2]); + vl(*[1:0]u8, @as([:0]u8, src_ptr50), 1, 1, src_ptr50[1..][0..1]); + vl([]u8, @as([:0]u8, src_ptr50), 1, dest_len, src_ptr50[1..][0..dest_len]); + ve(*[0]u8, @as([:0]u8, src_ptr50), 3, 3, src_ptr50[3..3]); + dest_end = 3; + ve([]u8, @as([:0]u8, src_ptr50), 3, dest_end, src_ptr50[3..dest_end]); + const src_ptr51: []u8 = src_mem10[0..1]; + vs(*[1]u8, @as([]u8, src_ptr51), 0, src_ptr51[0..]); + ve(*[1]u8, @as([]u8, src_ptr51), 0, 1, src_ptr51[0..1]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr51), 0, dest_end, src_ptr51[0..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr51), 0, 1, src_ptr51[0..][0..1]); + vl([]u8, @as([]u8, src_ptr51), 0, dest_len, src_ptr51[0..][0..dest_len]); + vs(*[0]u8, @as([]u8, src_ptr51), 1, src_ptr51[1..]); + ve(*[0]u8, @as([]u8, src_ptr51), 1, 1, src_ptr51[1..1]); + ve([]u8, @as([]u8, src_ptr51), 1, dest_end, src_ptr51[1..dest_end]); + const src_ptr52: [:0]u8 = src_mem11[0..0 :0]; + vs(*[0:0]u8, @as([:0]u8, src_ptr52), 0, src_ptr52[0..]); + ve(*[1]u8, @as([:0]u8, src_ptr52), 0, 1, src_ptr52[0..1]); + ve([]u8, @as([:0]u8, src_ptr52), 0, dest_end, src_ptr52[0..dest_end]); + vl(*[1]u8, @as([:0]u8, src_ptr52), 0, 1, src_ptr52[0..][0..1]); + vl([]u8, @as([:0]u8, src_ptr52), 0, dest_len, src_ptr52[0..][0..dest_len]); + ve(*[0]u8, @as([:0]u8, src_ptr52), 1, 1, src_ptr52[1..1]); + ve([]u8, @as([:0]u8, src_ptr52), 1, dest_end, src_ptr52[1..dest_end]); + var src_ptr53: []u8 = src_mem12[0..2]; + vs([]u8, @as([]u8, src_ptr53), 0, src_ptr53[0..]); + ve(*[2]u8, @as([]u8, src_ptr53), 0, 2, src_ptr53[0..2]); + ve(*[1]u8, @as([]u8, src_ptr53), 0, 1, src_ptr53[0..1]); + ve([]u8, @as([]u8, src_ptr53), 0, dest_end, src_ptr53[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr53), 0, 2, src_ptr53[0..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr53), 0, 1, src_ptr53[0..][0..1]); + vl([]u8, @as([]u8, src_ptr53), 0, dest_len, src_ptr53[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr53), 1, src_ptr53[1..]); + ve(*[1]u8, @as([]u8, src_ptr53), 1, 2, src_ptr53[1..2]); + ve(*[0]u8, @as([]u8, src_ptr53), 1, 1, src_ptr53[1..1]); + ve([]u8, @as([]u8, src_ptr53), 1, dest_end, src_ptr53[1..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr53), 1, 1, src_ptr53[1..][0..1]); + vl([]u8, @as([]u8, src_ptr53), 1, dest_len, src_ptr53[1..][0..dest_len]); + var src_ptr54: [:0]u8 = src_mem13[0..1 :0]; + vs([:0]u8, @as([:0]u8, src_ptr54), 0, src_ptr54[0..]); + ve(*[2]u8, @as([:0]u8, src_ptr54), 0, 2, src_ptr54[0..2]); + ve(*[1]u8, @as([:0]u8, src_ptr54), 0, 1, src_ptr54[0..1]); + ve([]u8, @as([:0]u8, src_ptr54), 0, dest_end, src_ptr54[0..dest_end]); + vl(*[2]u8, @as([:0]u8, src_ptr54), 0, 2, src_ptr54[0..][0..2]); + vl(*[1]u8, @as([:0]u8, src_ptr54), 0, 1, src_ptr54[0..][0..1]); + vl([]u8, @as([:0]u8, src_ptr54), 0, dest_len, src_ptr54[0..][0..dest_len]); + vs([:0]u8, @as([:0]u8, src_ptr54), 1, src_ptr54[1..]); + ve(*[1]u8, @as([:0]u8, src_ptr54), 1, 2, src_ptr54[1..2]); + ve(*[0]u8, @as([:0]u8, src_ptr54), 1, 1, src_ptr54[1..1]); + ve([]u8, @as([:0]u8, src_ptr54), 1, dest_end, src_ptr54[1..dest_end]); + vl(*[1]u8, @as([:0]u8, src_ptr54), 1, 1, src_ptr54[1..][0..1]); + vl([]u8, @as([:0]u8, src_ptr54), 1, dest_len, src_ptr54[1..][0..dest_len]); + var src_ptr55: []u8 = src_mem14[0..3]; + vs([]u8, @as([]u8, src_ptr55), 0, src_ptr55[0..]); + ve(*[2]u8, @as([]u8, src_ptr55), 0, 2, src_ptr55[0..2]); + ve(*[3]u8, @as([]u8, src_ptr55), 0, 3, src_ptr55[0..3]); + ve(*[1]u8, @as([]u8, src_ptr55), 0, 1, src_ptr55[0..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr55), 0, dest_end, src_ptr55[0..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr55), 0, dest_end, src_ptr55[0..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr55), 0, 2, src_ptr55[0..][0..2]); + vl(*[3]u8, @as([]u8, src_ptr55), 0, 3, src_ptr55[0..][0..3]); + vl(*[1]u8, @as([]u8, src_ptr55), 0, 1, src_ptr55[0..][0..1]); + dest_len = 3; + vl([]u8, @as([]u8, src_ptr55), 0, dest_len, src_ptr55[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([]u8, src_ptr55), 0, dest_len, src_ptr55[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr55), 1, src_ptr55[1..]); + ve(*[1]u8, @as([]u8, src_ptr55), 1, 2, src_ptr55[1..2]); + ve(*[2]u8, @as([]u8, src_ptr55), 1, 3, src_ptr55[1..3]); + ve(*[0]u8, @as([]u8, src_ptr55), 1, 1, src_ptr55[1..1]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr55), 1, dest_end, src_ptr55[1..dest_end]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr55), 1, dest_end, src_ptr55[1..dest_end]); + vl(*[2]u8, @as([]u8, src_ptr55), 1, 2, src_ptr55[1..][0..2]); + vl(*[1]u8, @as([]u8, src_ptr55), 1, 1, src_ptr55[1..][0..1]); + vl([]u8, @as([]u8, src_ptr55), 1, dest_len, src_ptr55[1..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr55), 3, src_ptr55[3..]); + ve(*[0]u8, @as([]u8, src_ptr55), 3, 3, src_ptr55[3..3]); + dest_end = 3; + ve([]u8, @as([]u8, src_ptr55), 3, dest_end, src_ptr55[3..dest_end]); + var src_ptr56: [:0]u8 = src_mem15[0..2 :0]; + vs([:0]u8, @as([:0]u8, src_ptr56), 0, src_ptr56[0..]); + ve(*[2]u8, @as([:0]u8, src_ptr56), 0, 2, src_ptr56[0..2]); + ve(*[3]u8, @as([:0]u8, src_ptr56), 0, 3, src_ptr56[0..3]); + ve(*[1]u8, @as([:0]u8, src_ptr56), 0, 1, src_ptr56[0..1]); + ve([]u8, @as([:0]u8, src_ptr56), 0, dest_end, src_ptr56[0..dest_end]); + dest_end = 1; + ve([]u8, @as([:0]u8, src_ptr56), 0, dest_end, src_ptr56[0..dest_end]); + vl(*[2]u8, @as([:0]u8, src_ptr56), 0, 2, src_ptr56[0..][0..2]); + vl(*[3]u8, @as([:0]u8, src_ptr56), 0, 3, src_ptr56[0..][0..3]); + vl(*[1]u8, @as([:0]u8, src_ptr56), 0, 1, src_ptr56[0..][0..1]); + dest_len = 3; + vl([]u8, @as([:0]u8, src_ptr56), 0, dest_len, src_ptr56[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([:0]u8, src_ptr56), 0, dest_len, src_ptr56[0..][0..dest_len]); + vs([:0]u8, @as([:0]u8, src_ptr56), 1, src_ptr56[1..]); + ve(*[1]u8, @as([:0]u8, src_ptr56), 1, 2, src_ptr56[1..2]); + ve(*[2]u8, @as([:0]u8, src_ptr56), 1, 3, src_ptr56[1..3]); + ve(*[0]u8, @as([:0]u8, src_ptr56), 1, 1, src_ptr56[1..1]); + dest_end = 3; + ve([]u8, @as([:0]u8, src_ptr56), 1, dest_end, src_ptr56[1..dest_end]); + dest_end = 1; + ve([]u8, @as([:0]u8, src_ptr56), 1, dest_end, src_ptr56[1..dest_end]); + vl(*[2]u8, @as([:0]u8, src_ptr56), 1, 2, src_ptr56[1..][0..2]); + vl(*[1]u8, @as([:0]u8, src_ptr56), 1, 1, src_ptr56[1..][0..1]); + vl([]u8, @as([:0]u8, src_ptr56), 1, dest_len, src_ptr56[1..][0..dest_len]); + ve(*[0]u8, @as([:0]u8, src_ptr56), 3, 3, src_ptr56[3..3]); + dest_end = 3; + ve([]u8, @as([:0]u8, src_ptr56), 3, dest_end, src_ptr56[3..dest_end]); + var src_ptr57: []u8 = src_mem16[0..1]; + vs([]u8, @as([]u8, src_ptr57), 0, src_ptr57[0..]); + ve(*[1]u8, @as([]u8, src_ptr57), 0, 1, src_ptr57[0..1]); + dest_end = 1; + ve([]u8, @as([]u8, src_ptr57), 0, dest_end, src_ptr57[0..dest_end]); + vl(*[1]u8, @as([]u8, src_ptr57), 0, 1, src_ptr57[0..][0..1]); + vl([]u8, @as([]u8, src_ptr57), 0, dest_len, src_ptr57[0..][0..dest_len]); + vs([]u8, @as([]u8, src_ptr57), 1, src_ptr57[1..]); + ve(*[0]u8, @as([]u8, src_ptr57), 1, 1, src_ptr57[1..1]); + ve([]u8, @as([]u8, src_ptr57), 1, dest_end, src_ptr57[1..dest_end]); + var src_ptr58: [:0]u8 = src_mem17[0..0 :0]; + vs([:0]u8, @as([:0]u8, src_ptr58), 0, src_ptr58[0..]); + ve(*[1]u8, @as([:0]u8, src_ptr58), 0, 1, src_ptr58[0..1]); + ve([]u8, @as([:0]u8, src_ptr58), 0, dest_end, src_ptr58[0..dest_end]); + vl(*[1]u8, @as([:0]u8, src_ptr58), 0, 1, src_ptr58[0..][0..1]); + vl([]u8, @as([:0]u8, src_ptr58), 0, dest_len, src_ptr58[0..][0..dest_len]); + ve(*[0]u8, @as([:0]u8, src_ptr58), 1, 1, src_ptr58[1..1]); + ve([]u8, @as([:0]u8, src_ptr58), 1, dest_end, src_ptr58[1..dest_end]); + const src_ptr59: [*]u8 = @ptrCast(&src_mem6); + vs([*]u8, @as([*]u8, src_ptr59), 0, src_ptr59[0..]); + ve(*[2]u8, @as([*]u8, src_ptr59), 0, 2, src_ptr59[0..2]); + ve(*[1]u8, @as([*]u8, src_ptr59), 0, 1, src_ptr59[0..1]); + ve([]u8, @as([*]u8, src_ptr59), 0, dest_end, src_ptr59[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr59), 0, 2, src_ptr59[0..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr59), 0, 1, src_ptr59[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr59), 0, dest_len, src_ptr59[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr59), 1, src_ptr59[1..]); + ve(*[1]u8, @as([*]u8, src_ptr59), 1, 2, src_ptr59[1..2]); + ve(*[0]u8, @as([*]u8, src_ptr59), 1, 1, src_ptr59[1..1]); + ve([]u8, @as([*]u8, src_ptr59), 1, dest_end, src_ptr59[1..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr59), 1, 1, src_ptr59[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr59), 1, dest_len, src_ptr59[1..][0..dest_len]); + vs([*:1]u8, @as([*]u8, src_ptr59), 0, src_ptr59[0.. :1]); + vs([*:1]u8, @as([*]u8, src_ptr59), 1, src_ptr59[1.. :1]); + const src_ptr60: [*:0]u8 = @ptrCast(&src_mem7); + vs([*]u8, @as([*:0]u8, src_ptr60), 0, src_ptr60[0..]); + ve(*[2]u8, @as([*:0]u8, src_ptr60), 0, 2, src_ptr60[0..2]); + ve(*[1]u8, @as([*:0]u8, src_ptr60), 0, 1, src_ptr60[0..1]); + ve([]u8, @as([*:0]u8, src_ptr60), 0, dest_end, src_ptr60[0..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr60), 0, 2, src_ptr60[0..][0..2]); + vl(*[1]u8, @as([*:0]u8, src_ptr60), 0, 1, src_ptr60[0..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr60), 0, dest_len, src_ptr60[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr60), 1, src_ptr60[1..]); + ve(*[1]u8, @as([*:0]u8, src_ptr60), 1, 2, src_ptr60[1..2]); + ve(*[0]u8, @as([*:0]u8, src_ptr60), 1, 1, src_ptr60[1..1]); + ve([]u8, @as([*:0]u8, src_ptr60), 1, dest_end, src_ptr60[1..dest_end]); + vl(*[1]u8, @as([*:0]u8, src_ptr60), 1, 1, src_ptr60[1..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr60), 1, dest_len, src_ptr60[1..][0..dest_len]); + vs([*:1]u8, @as([*:0]u8, src_ptr60), 0, src_ptr60[0.. :1]); + vs([*:1]u8, @as([*:0]u8, src_ptr60), 1, src_ptr60[1.. :1]); + const src_ptr61: [*]u8 = @ptrCast(&src_mem8); + vs([*]u8, @as([*]u8, src_ptr61), 0, src_ptr61[0..]); + ve(*[2]u8, @as([*]u8, src_ptr61), 0, 2, src_ptr61[0..2]); + ve(*[3]u8, @as([*]u8, src_ptr61), 0, 3, src_ptr61[0..3]); + ve(*[1]u8, @as([*]u8, src_ptr61), 0, 1, src_ptr61[0..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr61), 0, dest_end, src_ptr61[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr61), 0, dest_end, src_ptr61[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr61), 0, 2, src_ptr61[0..][0..2]); + vl(*[3]u8, @as([*]u8, src_ptr61), 0, 3, src_ptr61[0..][0..3]); + vl(*[1]u8, @as([*]u8, src_ptr61), 0, 1, src_ptr61[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*]u8, src_ptr61), 0, dest_len, src_ptr61[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*]u8, src_ptr61), 0, dest_len, src_ptr61[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr61), 1, src_ptr61[1..]); + ve(*[1]u8, @as([*]u8, src_ptr61), 1, 2, src_ptr61[1..2]); + ve(*[2]u8, @as([*]u8, src_ptr61), 1, 3, src_ptr61[1..3]); + ve(*[0]u8, @as([*]u8, src_ptr61), 1, 1, src_ptr61[1..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr61), 1, dest_end, src_ptr61[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr61), 1, dest_end, src_ptr61[1..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr61), 1, 2, src_ptr61[1..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr61), 1, 1, src_ptr61[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr61), 1, dest_len, src_ptr61[1..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr61), 3, src_ptr61[3..]); + ve(*[0]u8, @as([*]u8, src_ptr61), 3, 3, src_ptr61[3..3]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr61), 3, dest_end, src_ptr61[3..dest_end]); + vs([*:1]u8, @as([*]u8, src_ptr61), 0, src_ptr61[0.. :1]); + vs([*:1]u8, @as([*]u8, src_ptr61), 1, src_ptr61[1.. :1]); + const src_ptr62: [*:0]u8 = @ptrCast(&src_mem9); + vs([*]u8, @as([*:0]u8, src_ptr62), 0, src_ptr62[0..]); + ve(*[2]u8, @as([*:0]u8, src_ptr62), 0, 2, src_ptr62[0..2]); + ve(*[3]u8, @as([*:0]u8, src_ptr62), 0, 3, src_ptr62[0..3]); + ve(*[1]u8, @as([*:0]u8, src_ptr62), 0, 1, src_ptr62[0..1]); + ve([]u8, @as([*:0]u8, src_ptr62), 0, dest_end, src_ptr62[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*:0]u8, src_ptr62), 0, dest_end, src_ptr62[0..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr62), 0, 2, src_ptr62[0..][0..2]); + vl(*[3]u8, @as([*:0]u8, src_ptr62), 0, 3, src_ptr62[0..][0..3]); + vl(*[1]u8, @as([*:0]u8, src_ptr62), 0, 1, src_ptr62[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*:0]u8, src_ptr62), 0, dest_len, src_ptr62[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*:0]u8, src_ptr62), 0, dest_len, src_ptr62[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr62), 1, src_ptr62[1..]); + ve(*[1]u8, @as([*:0]u8, src_ptr62), 1, 2, src_ptr62[1..2]); + ve(*[2]u8, @as([*:0]u8, src_ptr62), 1, 3, src_ptr62[1..3]); + ve(*[0]u8, @as([*:0]u8, src_ptr62), 1, 1, src_ptr62[1..1]); + dest_end = 3; + ve([]u8, @as([*:0]u8, src_ptr62), 1, dest_end, src_ptr62[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*:0]u8, src_ptr62), 1, dest_end, src_ptr62[1..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr62), 1, 2, src_ptr62[1..][0..2]); + vl(*[1]u8, @as([*:0]u8, src_ptr62), 1, 1, src_ptr62[1..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr62), 1, dest_len, src_ptr62[1..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr62), 3, src_ptr62[3..]); + ve(*[0]u8, @as([*:0]u8, src_ptr62), 3, 3, src_ptr62[3..3]); + dest_end = 3; + ve([]u8, @as([*:0]u8, src_ptr62), 3, dest_end, src_ptr62[3..dest_end]); + vs([*:1]u8, @as([*:0]u8, src_ptr62), 0, src_ptr62[0.. :1]); + vs([*:1]u8, @as([*:0]u8, src_ptr62), 1, src_ptr62[1.. :1]); + const src_ptr63: [*]u8 = @ptrCast(&src_mem10); + vs([*]u8, @as([*]u8, src_ptr63), 0, src_ptr63[0..]); + ve(*[1]u8, @as([*]u8, src_ptr63), 0, 1, src_ptr63[0..1]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr63), 0, dest_end, src_ptr63[0..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr63), 0, 1, src_ptr63[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr63), 0, dest_len, src_ptr63[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr63), 1, src_ptr63[1..]); + ve(*[0]u8, @as([*]u8, src_ptr63), 1, 1, src_ptr63[1..1]); + ve([]u8, @as([*]u8, src_ptr63), 1, dest_end, src_ptr63[1..dest_end]); + vs([*:1]u8, @as([*]u8, src_ptr63), 0, src_ptr63[0.. :1]); + const src_ptr64: [*:0]u8 = @ptrCast(&src_mem11); + vs([*]u8, @as([*:0]u8, src_ptr64), 0, src_ptr64[0..]); + ve(*[1]u8, @as([*:0]u8, src_ptr64), 0, 1, src_ptr64[0..1]); + ve([]u8, @as([*:0]u8, src_ptr64), 0, dest_end, src_ptr64[0..dest_end]); + vl(*[1]u8, @as([*:0]u8, src_ptr64), 0, 1, src_ptr64[0..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr64), 0, dest_len, src_ptr64[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr64), 1, src_ptr64[1..]); + ve(*[0]u8, @as([*:0]u8, src_ptr64), 1, 1, src_ptr64[1..1]); + ve([]u8, @as([*:0]u8, src_ptr64), 1, dest_end, src_ptr64[1..dest_end]); + vs([*:1]u8, @as([*:0]u8, src_ptr64), 0, src_ptr64[0.. :1]); + var src_ptr65: [*]u8 = @ptrCast(&src_mem12); + vs([*]u8, @as([*]u8, src_ptr65), 0, src_ptr65[0..]); + ve(*[2]u8, @as([*]u8, src_ptr65), 0, 2, src_ptr65[0..2]); + ve(*[1]u8, @as([*]u8, src_ptr65), 0, 1, src_ptr65[0..1]); + ve([]u8, @as([*]u8, src_ptr65), 0, dest_end, src_ptr65[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr65), 0, 2, src_ptr65[0..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr65), 0, 1, src_ptr65[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr65), 0, dest_len, src_ptr65[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr65), 1, src_ptr65[1..]); + ve(*[1]u8, @as([*]u8, src_ptr65), 1, 2, src_ptr65[1..2]); + ve(*[0]u8, @as([*]u8, src_ptr65), 1, 1, src_ptr65[1..1]); + ve([]u8, @as([*]u8, src_ptr65), 1, dest_end, src_ptr65[1..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr65), 1, 1, src_ptr65[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr65), 1, dest_len, src_ptr65[1..][0..dest_len]); + vs([*:1]u8, @as([*]u8, src_ptr65), 0, src_ptr65[0.. :1]); + vs([*:1]u8, @as([*]u8, src_ptr65), 1, src_ptr65[1.. :1]); + var src_ptr66: [*:0]u8 = @ptrCast(&src_mem13); + vs([*]u8, @as([*:0]u8, src_ptr66), 0, src_ptr66[0..]); + ve(*[2]u8, @as([*:0]u8, src_ptr66), 0, 2, src_ptr66[0..2]); + ve(*[1]u8, @as([*:0]u8, src_ptr66), 0, 1, src_ptr66[0..1]); + ve([]u8, @as([*:0]u8, src_ptr66), 0, dest_end, src_ptr66[0..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr66), 0, 2, src_ptr66[0..][0..2]); + vl(*[1]u8, @as([*:0]u8, src_ptr66), 0, 1, src_ptr66[0..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr66), 0, dest_len, src_ptr66[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr66), 1, src_ptr66[1..]); + ve(*[1]u8, @as([*:0]u8, src_ptr66), 1, 2, src_ptr66[1..2]); + ve(*[0]u8, @as([*:0]u8, src_ptr66), 1, 1, src_ptr66[1..1]); + ve([]u8, @as([*:0]u8, src_ptr66), 1, dest_end, src_ptr66[1..dest_end]); + vl(*[1]u8, @as([*:0]u8, src_ptr66), 1, 1, src_ptr66[1..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr66), 1, dest_len, src_ptr66[1..][0..dest_len]); + vs([*:1]u8, @as([*:0]u8, src_ptr66), 0, src_ptr66[0.. :1]); + vs([*:1]u8, @as([*:0]u8, src_ptr66), 1, src_ptr66[1.. :1]); + var src_ptr67: [*]u8 = @ptrCast(&src_mem14); + vs([*]u8, @as([*]u8, src_ptr67), 0, src_ptr67[0..]); + ve(*[2]u8, @as([*]u8, src_ptr67), 0, 2, src_ptr67[0..2]); + ve(*[3]u8, @as([*]u8, src_ptr67), 0, 3, src_ptr67[0..3]); + ve(*[1]u8, @as([*]u8, src_ptr67), 0, 1, src_ptr67[0..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr67), 0, dest_end, src_ptr67[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr67), 0, dest_end, src_ptr67[0..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr67), 0, 2, src_ptr67[0..][0..2]); + vl(*[3]u8, @as([*]u8, src_ptr67), 0, 3, src_ptr67[0..][0..3]); + vl(*[1]u8, @as([*]u8, src_ptr67), 0, 1, src_ptr67[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*]u8, src_ptr67), 0, dest_len, src_ptr67[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*]u8, src_ptr67), 0, dest_len, src_ptr67[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr67), 1, src_ptr67[1..]); + ve(*[1]u8, @as([*]u8, src_ptr67), 1, 2, src_ptr67[1..2]); + ve(*[2]u8, @as([*]u8, src_ptr67), 1, 3, src_ptr67[1..3]); + ve(*[0]u8, @as([*]u8, src_ptr67), 1, 1, src_ptr67[1..1]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr67), 1, dest_end, src_ptr67[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr67), 1, dest_end, src_ptr67[1..dest_end]); + vl(*[2]u8, @as([*]u8, src_ptr67), 1, 2, src_ptr67[1..][0..2]); + vl(*[1]u8, @as([*]u8, src_ptr67), 1, 1, src_ptr67[1..][0..1]); + vl([]u8, @as([*]u8, src_ptr67), 1, dest_len, src_ptr67[1..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr67), 3, src_ptr67[3..]); + ve(*[0]u8, @as([*]u8, src_ptr67), 3, 3, src_ptr67[3..3]); + dest_end = 3; + ve([]u8, @as([*]u8, src_ptr67), 3, dest_end, src_ptr67[3..dest_end]); + vs([*:1]u8, @as([*]u8, src_ptr67), 0, src_ptr67[0.. :1]); + vs([*:1]u8, @as([*]u8, src_ptr67), 1, src_ptr67[1.. :1]); + var src_ptr68: [*:0]u8 = @ptrCast(&src_mem15); + vs([*]u8, @as([*:0]u8, src_ptr68), 0, src_ptr68[0..]); + ve(*[2]u8, @as([*:0]u8, src_ptr68), 0, 2, src_ptr68[0..2]); + ve(*[3]u8, @as([*:0]u8, src_ptr68), 0, 3, src_ptr68[0..3]); + ve(*[1]u8, @as([*:0]u8, src_ptr68), 0, 1, src_ptr68[0..1]); + ve([]u8, @as([*:0]u8, src_ptr68), 0, dest_end, src_ptr68[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*:0]u8, src_ptr68), 0, dest_end, src_ptr68[0..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr68), 0, 2, src_ptr68[0..][0..2]); + vl(*[3]u8, @as([*:0]u8, src_ptr68), 0, 3, src_ptr68[0..][0..3]); + vl(*[1]u8, @as([*:0]u8, src_ptr68), 0, 1, src_ptr68[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*:0]u8, src_ptr68), 0, dest_len, src_ptr68[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*:0]u8, src_ptr68), 0, dest_len, src_ptr68[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr68), 1, src_ptr68[1..]); + ve(*[1]u8, @as([*:0]u8, src_ptr68), 1, 2, src_ptr68[1..2]); + ve(*[2]u8, @as([*:0]u8, src_ptr68), 1, 3, src_ptr68[1..3]); + ve(*[0]u8, @as([*:0]u8, src_ptr68), 1, 1, src_ptr68[1..1]); + dest_end = 3; + ve([]u8, @as([*:0]u8, src_ptr68), 1, dest_end, src_ptr68[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*:0]u8, src_ptr68), 1, dest_end, src_ptr68[1..dest_end]); + vl(*[2]u8, @as([*:0]u8, src_ptr68), 1, 2, src_ptr68[1..][0..2]); + vl(*[1]u8, @as([*:0]u8, src_ptr68), 1, 1, src_ptr68[1..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr68), 1, dest_len, src_ptr68[1..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr68), 3, src_ptr68[3..]); + ve(*[0]u8, @as([*:0]u8, src_ptr68), 3, 3, src_ptr68[3..3]); + dest_end = 3; + ve([]u8, @as([*:0]u8, src_ptr68), 3, dest_end, src_ptr68[3..dest_end]); + vs([*:1]u8, @as([*:0]u8, src_ptr68), 0, src_ptr68[0.. :1]); + vs([*:1]u8, @as([*:0]u8, src_ptr68), 1, src_ptr68[1.. :1]); + var src_ptr69: [*]u8 = @ptrCast(&src_mem16); + vs([*]u8, @as([*]u8, src_ptr69), 0, src_ptr69[0..]); + ve(*[1]u8, @as([*]u8, src_ptr69), 0, 1, src_ptr69[0..1]); + dest_end = 1; + ve([]u8, @as([*]u8, src_ptr69), 0, dest_end, src_ptr69[0..dest_end]); + vl(*[1]u8, @as([*]u8, src_ptr69), 0, 1, src_ptr69[0..][0..1]); + vl([]u8, @as([*]u8, src_ptr69), 0, dest_len, src_ptr69[0..][0..dest_len]); + vs([*]u8, @as([*]u8, src_ptr69), 1, src_ptr69[1..]); + ve(*[0]u8, @as([*]u8, src_ptr69), 1, 1, src_ptr69[1..1]); + ve([]u8, @as([*]u8, src_ptr69), 1, dest_end, src_ptr69[1..dest_end]); + vs([*:1]u8, @as([*]u8, src_ptr69), 0, src_ptr69[0.. :1]); + var src_ptr70: [*:0]u8 = @ptrCast(&src_mem17); + vs([*]u8, @as([*:0]u8, src_ptr70), 0, src_ptr70[0..]); + ve(*[1]u8, @as([*:0]u8, src_ptr70), 0, 1, src_ptr70[0..1]); + ve([]u8, @as([*:0]u8, src_ptr70), 0, dest_end, src_ptr70[0..dest_end]); + vl(*[1]u8, @as([*:0]u8, src_ptr70), 0, 1, src_ptr70[0..][0..1]); + vl([]u8, @as([*:0]u8, src_ptr70), 0, dest_len, src_ptr70[0..][0..dest_len]); + vs([*]u8, @as([*:0]u8, src_ptr70), 1, src_ptr70[1..]); + ve(*[0]u8, @as([*:0]u8, src_ptr70), 1, 1, src_ptr70[1..1]); + ve([]u8, @as([*:0]u8, src_ptr70), 1, dest_end, src_ptr70[1..dest_end]); + vs([*:1]u8, @as([*:0]u8, src_ptr70), 0, src_ptr70[0.. :1]); + const src_ptr71: [*c]u8 = @ptrCast(&src_mem6); + vs([*c]u8, @as([*c]u8, src_ptr71), 0, src_ptr71[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr71), 0, 2, src_ptr71[0..2]); + ve(*[1]u8, @as([*c]u8, src_ptr71), 0, 1, src_ptr71[0..1]); + ve([]u8, @as([*c]u8, src_ptr71), 0, dest_end, src_ptr71[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr71), 0, 2, src_ptr71[0..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr71), 0, 1, src_ptr71[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr71), 0, dest_len, src_ptr71[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr71), 1, src_ptr71[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr71), 1, 2, src_ptr71[1..2]); + ve(*[0]u8, @as([*c]u8, src_ptr71), 1, 1, src_ptr71[1..1]); + ve([]u8, @as([*c]u8, src_ptr71), 1, dest_end, src_ptr71[1..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr71), 1, 1, src_ptr71[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr71), 1, dest_len, src_ptr71[1..][0..dest_len]); + vs([*:1]u8, @as([*c]u8, src_ptr71), 0, src_ptr71[0.. :1]); + vs([*:1]u8, @as([*c]u8, src_ptr71), 1, src_ptr71[1.. :1]); + const src_ptr72: [*c]u8 = @ptrCast(&src_mem8); + vs([*c]u8, @as([*c]u8, src_ptr72), 0, src_ptr72[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr72), 0, 2, src_ptr72[0..2]); + ve(*[3]u8, @as([*c]u8, src_ptr72), 0, 3, src_ptr72[0..3]); + ve(*[1]u8, @as([*c]u8, src_ptr72), 0, 1, src_ptr72[0..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr72), 0, dest_end, src_ptr72[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr72), 0, dest_end, src_ptr72[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr72), 0, 2, src_ptr72[0..][0..2]); + vl(*[3]u8, @as([*c]u8, src_ptr72), 0, 3, src_ptr72[0..][0..3]); + vl(*[1]u8, @as([*c]u8, src_ptr72), 0, 1, src_ptr72[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*c]u8, src_ptr72), 0, dest_len, src_ptr72[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*c]u8, src_ptr72), 0, dest_len, src_ptr72[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr72), 1, src_ptr72[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr72), 1, 2, src_ptr72[1..2]); + ve(*[2]u8, @as([*c]u8, src_ptr72), 1, 3, src_ptr72[1..3]); + ve(*[0]u8, @as([*c]u8, src_ptr72), 1, 1, src_ptr72[1..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr72), 1, dest_end, src_ptr72[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr72), 1, dest_end, src_ptr72[1..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr72), 1, 2, src_ptr72[1..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr72), 1, 1, src_ptr72[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr72), 1, dest_len, src_ptr72[1..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr72), 3, src_ptr72[3..]); + ve(*[0]u8, @as([*c]u8, src_ptr72), 3, 3, src_ptr72[3..3]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr72), 3, dest_end, src_ptr72[3..dest_end]); + vs([*:1]u8, @as([*c]u8, src_ptr72), 0, src_ptr72[0.. :1]); + vs([*:1]u8, @as([*c]u8, src_ptr72), 1, src_ptr72[1.. :1]); + const src_ptr73: [*c]u8 = @ptrCast(&src_mem10); + vs([*c]u8, @as([*c]u8, src_ptr73), 0, src_ptr73[0..]); + ve(*[1]u8, @as([*c]u8, src_ptr73), 0, 1, src_ptr73[0..1]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr73), 0, dest_end, src_ptr73[0..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr73), 0, 1, src_ptr73[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr73), 0, dest_len, src_ptr73[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr73), 1, src_ptr73[1..]); + ve(*[0]u8, @as([*c]u8, src_ptr73), 1, 1, src_ptr73[1..1]); + ve([]u8, @as([*c]u8, src_ptr73), 1, dest_end, src_ptr73[1..dest_end]); + vs([*:1]u8, @as([*c]u8, src_ptr73), 0, src_ptr73[0.. :1]); + var src_ptr74: [*c]u8 = @ptrCast(&src_mem12); + vs([*c]u8, @as([*c]u8, src_ptr74), 0, src_ptr74[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr74), 0, 2, src_ptr74[0..2]); + ve(*[1]u8, @as([*c]u8, src_ptr74), 0, 1, src_ptr74[0..1]); + ve([]u8, @as([*c]u8, src_ptr74), 0, dest_end, src_ptr74[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr74), 0, 2, src_ptr74[0..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr74), 0, 1, src_ptr74[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr74), 0, dest_len, src_ptr74[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr74), 1, src_ptr74[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr74), 1, 2, src_ptr74[1..2]); + ve(*[0]u8, @as([*c]u8, src_ptr74), 1, 1, src_ptr74[1..1]); + ve([]u8, @as([*c]u8, src_ptr74), 1, dest_end, src_ptr74[1..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr74), 1, 1, src_ptr74[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr74), 1, dest_len, src_ptr74[1..][0..dest_len]); + vs([*:1]u8, @as([*c]u8, src_ptr74), 0, src_ptr74[0.. :1]); + vs([*:1]u8, @as([*c]u8, src_ptr74), 1, src_ptr74[1.. :1]); + var src_ptr75: [*c]u8 = @ptrCast(&src_mem14); + vs([*c]u8, @as([*c]u8, src_ptr75), 0, src_ptr75[0..]); + ve(*[2]u8, @as([*c]u8, src_ptr75), 0, 2, src_ptr75[0..2]); + ve(*[3]u8, @as([*c]u8, src_ptr75), 0, 3, src_ptr75[0..3]); + ve(*[1]u8, @as([*c]u8, src_ptr75), 0, 1, src_ptr75[0..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr75), 0, dest_end, src_ptr75[0..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr75), 0, dest_end, src_ptr75[0..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr75), 0, 2, src_ptr75[0..][0..2]); + vl(*[3]u8, @as([*c]u8, src_ptr75), 0, 3, src_ptr75[0..][0..3]); + vl(*[1]u8, @as([*c]u8, src_ptr75), 0, 1, src_ptr75[0..][0..1]); + dest_len = 3; + vl([]u8, @as([*c]u8, src_ptr75), 0, dest_len, src_ptr75[0..][0..dest_len]); + dest_len = 1; + vl([]u8, @as([*c]u8, src_ptr75), 0, dest_len, src_ptr75[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr75), 1, src_ptr75[1..]); + ve(*[1]u8, @as([*c]u8, src_ptr75), 1, 2, src_ptr75[1..2]); + ve(*[2]u8, @as([*c]u8, src_ptr75), 1, 3, src_ptr75[1..3]); + ve(*[0]u8, @as([*c]u8, src_ptr75), 1, 1, src_ptr75[1..1]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr75), 1, dest_end, src_ptr75[1..dest_end]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr75), 1, dest_end, src_ptr75[1..dest_end]); + vl(*[2]u8, @as([*c]u8, src_ptr75), 1, 2, src_ptr75[1..][0..2]); + vl(*[1]u8, @as([*c]u8, src_ptr75), 1, 1, src_ptr75[1..][0..1]); + vl([]u8, @as([*c]u8, src_ptr75), 1, dest_len, src_ptr75[1..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr75), 3, src_ptr75[3..]); + ve(*[0]u8, @as([*c]u8, src_ptr75), 3, 3, src_ptr75[3..3]); + dest_end = 3; + ve([]u8, @as([*c]u8, src_ptr75), 3, dest_end, src_ptr75[3..dest_end]); + vs([*:1]u8, @as([*c]u8, src_ptr75), 0, src_ptr75[0.. :1]); + vs([*:1]u8, @as([*c]u8, src_ptr75), 1, src_ptr75[1.. :1]); + var src_ptr76: [*c]u8 = @ptrCast(&src_mem16); + vs([*c]u8, @as([*c]u8, src_ptr76), 0, src_ptr76[0..]); + ve(*[1]u8, @as([*c]u8, src_ptr76), 0, 1, src_ptr76[0..1]); + dest_end = 1; + ve([]u8, @as([*c]u8, src_ptr76), 0, dest_end, src_ptr76[0..dest_end]); + vl(*[1]u8, @as([*c]u8, src_ptr76), 0, 1, src_ptr76[0..][0..1]); + vl([]u8, @as([*c]u8, src_ptr76), 0, dest_len, src_ptr76[0..][0..dest_len]); + vs([*c]u8, @as([*c]u8, src_ptr76), 1, src_ptr76[1..]); + ve(*[0]u8, @as([*c]u8, src_ptr76), 1, 1, src_ptr76[1..1]); + ve([]u8, @as([*c]u8, src_ptr76), 1, dest_end, src_ptr76[1..dest_end]); + vs([*:1]u8, @as([*c]u8, src_ptr76), 0, src_ptr76[0.. :1]); + const src_mem18: [2]u8 = .{ 0, 0 }; + const src_ptr77: *const [2]u8 = src_mem18[0..2]; + vs(*const [2]u8, @as(*const [2]u8, src_ptr77), 0, src_ptr77[0..]); + ve(*const [2]u8, @as(*const [2]u8, src_ptr77), 0, 2, src_ptr77[0..2]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr77), 0, 1, src_ptr77[0..1]); + ve([]const u8, @as(*const [2]u8, src_ptr77), 0, dest_end, src_ptr77[0..dest_end]); + vl(*const [2]u8, @as(*const [2]u8, src_ptr77), 0, 2, src_ptr77[0..][0..2]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr77), 0, 1, src_ptr77[0..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr77), 0, dest_len, src_ptr77[0..][0..dest_len]); + vs(*const [1]u8, @as(*const [2]u8, src_ptr77), 1, src_ptr77[1..]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr77), 1, 2, src_ptr77[1..2]); + ve(*const [0]u8, @as(*const [2]u8, src_ptr77), 1, 1, src_ptr77[1..1]); + ve([]const u8, @as(*const [2]u8, src_ptr77), 1, dest_end, src_ptr77[1..dest_end]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr77), 1, 1, src_ptr77[1..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr77), 1, dest_len, src_ptr77[1..][0..dest_len]); + const src_mem19: [2]u8 = .{ 0, 0 }; + const src_ptr78: *const [1:0]u8 = src_mem19[0..1 :0]; + vs(*const [1:0]u8, @as(*const [1:0]u8, src_ptr78), 0, src_ptr78[0..]); + ve(*const [2]u8, @as(*const [1:0]u8, src_ptr78), 0, 2, src_ptr78[0..2]); + ve(*const [1:0]u8, @as(*const [1:0]u8, src_ptr78), 0, 1, src_ptr78[0..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr78), 0, dest_end, src_ptr78[0..dest_end]); + vl(*const [2]u8, @as(*const [1:0]u8, src_ptr78), 0, 2, src_ptr78[0..][0..2]); + vl(*const [1:0]u8, @as(*const [1:0]u8, src_ptr78), 0, 1, src_ptr78[0..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr78), 0, dest_len, src_ptr78[0..][0..dest_len]); + vs(*const [0:0]u8, @as(*const [1:0]u8, src_ptr78), 1, src_ptr78[1..]); + ve(*const [1]u8, @as(*const [1:0]u8, src_ptr78), 1, 2, src_ptr78[1..2]); + ve(*const [0:0]u8, @as(*const [1:0]u8, src_ptr78), 1, 1, src_ptr78[1..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr78), 1, dest_end, src_ptr78[1..dest_end]); + vl(*const [1]u8, @as(*const [1:0]u8, src_ptr78), 1, 1, src_ptr78[1..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr78), 1, dest_len, src_ptr78[1..][0..dest_len]); + const src_mem20: [3]u8 = .{ 0, 0, 0 }; + const src_ptr79: *const [3]u8 = src_mem20[0..3]; + vs(*const [3]u8, @as(*const [3]u8, src_ptr79), 0, src_ptr79[0..]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr79), 0, 2, src_ptr79[0..2]); + ve(*const [3]u8, @as(*const [3]u8, src_ptr79), 0, 3, src_ptr79[0..3]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr79), 0, 1, src_ptr79[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr79), 0, dest_end, src_ptr79[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr79), 0, dest_end, src_ptr79[0..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr79), 0, 2, src_ptr79[0..][0..2]); + vl(*const [3]u8, @as(*const [3]u8, src_ptr79), 0, 3, src_ptr79[0..][0..3]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr79), 0, 1, src_ptr79[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [3]u8, src_ptr79), 0, dest_len, src_ptr79[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [3]u8, src_ptr79), 0, dest_len, src_ptr79[0..][0..dest_len]); + vs(*const [2]u8, @as(*const [3]u8, src_ptr79), 1, src_ptr79[1..]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr79), 1, 2, src_ptr79[1..2]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr79), 1, 3, src_ptr79[1..3]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr79), 1, 1, src_ptr79[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr79), 1, dest_end, src_ptr79[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr79), 1, dest_end, src_ptr79[1..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr79), 1, 2, src_ptr79[1..][0..2]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr79), 1, 1, src_ptr79[1..][0..1]); + vl([]const u8, @as(*const [3]u8, src_ptr79), 1, dest_len, src_ptr79[1..][0..dest_len]); + vs(*const [0]u8, @as(*const [3]u8, src_ptr79), 3, src_ptr79[3..]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr79), 3, 3, src_ptr79[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr79), 3, dest_end, src_ptr79[3..dest_end]); + const src_mem21: [3]u8 = .{ 0, 0, 0 }; + const src_ptr80: *const [2:0]u8 = src_mem21[0..2 :0]; + vs(*const [2:0]u8, @as(*const [2:0]u8, src_ptr80), 0, src_ptr80[0..]); + ve(*const [2:0]u8, @as(*const [2:0]u8, src_ptr80), 0, 2, src_ptr80[0..2]); + ve(*const [3]u8, @as(*const [2:0]u8, src_ptr80), 0, 3, src_ptr80[0..3]); + ve(*const [1]u8, @as(*const [2:0]u8, src_ptr80), 0, 1, src_ptr80[0..1]); + ve([]const u8, @as(*const [2:0]u8, src_ptr80), 0, dest_end, src_ptr80[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr80), 0, dest_end, src_ptr80[0..dest_end]); + vl(*const [2:0]u8, @as(*const [2:0]u8, src_ptr80), 0, 2, src_ptr80[0..][0..2]); + vl(*const [3]u8, @as(*const [2:0]u8, src_ptr80), 0, 3, src_ptr80[0..][0..3]); + vl(*const [1]u8, @as(*const [2:0]u8, src_ptr80), 0, 1, src_ptr80[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [2:0]u8, src_ptr80), 0, dest_len, src_ptr80[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [2:0]u8, src_ptr80), 0, dest_len, src_ptr80[0..][0..dest_len]); + vs(*const [1:0]u8, @as(*const [2:0]u8, src_ptr80), 1, src_ptr80[1..]); + ve(*const [1:0]u8, @as(*const [2:0]u8, src_ptr80), 1, 2, src_ptr80[1..2]); + ve(*const [2]u8, @as(*const [2:0]u8, src_ptr80), 1, 3, src_ptr80[1..3]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr80), 1, 1, src_ptr80[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr80), 1, dest_end, src_ptr80[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr80), 1, dest_end, src_ptr80[1..dest_end]); + vl(*const [2]u8, @as(*const [2:0]u8, src_ptr80), 1, 2, src_ptr80[1..][0..2]); + vl(*const [1:0]u8, @as(*const [2:0]u8, src_ptr80), 1, 1, src_ptr80[1..][0..1]); + vl([]const u8, @as(*const [2:0]u8, src_ptr80), 1, dest_len, src_ptr80[1..][0..dest_len]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr80), 3, 3, src_ptr80[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr80), 3, dest_end, src_ptr80[3..dest_end]); + const src_mem22: [1]u8 = .{0}; + const src_ptr81: *const [1]u8 = src_mem22[0..1]; + vs(*const [1]u8, @as(*const [1]u8, src_ptr81), 0, src_ptr81[0..]); + ve(*const [1]u8, @as(*const [1]u8, src_ptr81), 0, 1, src_ptr81[0..1]); + dest_end = 1; + ve([]const u8, @as(*const [1]u8, src_ptr81), 0, dest_end, src_ptr81[0..dest_end]); + vl(*const [1]u8, @as(*const [1]u8, src_ptr81), 0, 1, src_ptr81[0..][0..1]); + vl([]const u8, @as(*const [1]u8, src_ptr81), 0, dest_len, src_ptr81[0..][0..dest_len]); + vs(*const [0]u8, @as(*const [1]u8, src_ptr81), 1, src_ptr81[1..]); + ve(*const [0]u8, @as(*const [1]u8, src_ptr81), 1, 1, src_ptr81[1..1]); + ve([]const u8, @as(*const [1]u8, src_ptr81), 1, dest_end, src_ptr81[1..dest_end]); + const src_mem23: [1]u8 = .{0}; + const src_ptr82: *const [0:0]u8 = src_mem23[0..0 :0]; + vs(*const [0:0]u8, @as(*const [0:0]u8, src_ptr82), 0, src_ptr82[0..]); + ve(*const [1]u8, @as(*const [0:0]u8, src_ptr82), 0, 1, src_ptr82[0..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr82), 0, dest_end, src_ptr82[0..dest_end]); + vl(*const [1]u8, @as(*const [0:0]u8, src_ptr82), 0, 1, src_ptr82[0..][0..1]); + vl([]const u8, @as(*const [0:0]u8, src_ptr82), 0, dest_len, src_ptr82[0..][0..dest_len]); + ve(*const [0]u8, @as(*const [0:0]u8, src_ptr82), 1, 1, src_ptr82[1..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr82), 1, dest_end, src_ptr82[1..dest_end]); + var src_ptr83: *const [2]u8 = src_mem18[0..2]; + vs(*const [2]u8, @as(*const [2]u8, src_ptr83), 0, src_ptr83[0..]); + ve(*const [2]u8, @as(*const [2]u8, src_ptr83), 0, 2, src_ptr83[0..2]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr83), 0, 1, src_ptr83[0..1]); + ve([]const u8, @as(*const [2]u8, src_ptr83), 0, dest_end, src_ptr83[0..dest_end]); + vl(*const [2]u8, @as(*const [2]u8, src_ptr83), 0, 2, src_ptr83[0..][0..2]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr83), 0, 1, src_ptr83[0..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr83), 0, dest_len, src_ptr83[0..][0..dest_len]); + vs(*const [1]u8, @as(*const [2]u8, src_ptr83), 1, src_ptr83[1..]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr83), 1, 2, src_ptr83[1..2]); + ve(*const [0]u8, @as(*const [2]u8, src_ptr83), 1, 1, src_ptr83[1..1]); + ve([]const u8, @as(*const [2]u8, src_ptr83), 1, dest_end, src_ptr83[1..dest_end]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr83), 1, 1, src_ptr83[1..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr83), 1, dest_len, src_ptr83[1..][0..dest_len]); + var src_ptr84: *const [1:0]u8 = src_mem19[0..1 :0]; + vs(*const [1:0]u8, @as(*const [1:0]u8, src_ptr84), 0, src_ptr84[0..]); + ve(*const [2]u8, @as(*const [1:0]u8, src_ptr84), 0, 2, src_ptr84[0..2]); + ve(*const [1:0]u8, @as(*const [1:0]u8, src_ptr84), 0, 1, src_ptr84[0..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr84), 0, dest_end, src_ptr84[0..dest_end]); + vl(*const [2]u8, @as(*const [1:0]u8, src_ptr84), 0, 2, src_ptr84[0..][0..2]); + vl(*const [1:0]u8, @as(*const [1:0]u8, src_ptr84), 0, 1, src_ptr84[0..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr84), 0, dest_len, src_ptr84[0..][0..dest_len]); + vs(*const [0:0]u8, @as(*const [1:0]u8, src_ptr84), 1, src_ptr84[1..]); + ve(*const [1]u8, @as(*const [1:0]u8, src_ptr84), 1, 2, src_ptr84[1..2]); + ve(*const [0:0]u8, @as(*const [1:0]u8, src_ptr84), 1, 1, src_ptr84[1..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr84), 1, dest_end, src_ptr84[1..dest_end]); + vl(*const [1]u8, @as(*const [1:0]u8, src_ptr84), 1, 1, src_ptr84[1..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr84), 1, dest_len, src_ptr84[1..][0..dest_len]); + var src_ptr85: *const [3]u8 = src_mem20[0..3]; + vs(*const [3]u8, @as(*const [3]u8, src_ptr85), 0, src_ptr85[0..]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr85), 0, 2, src_ptr85[0..2]); + ve(*const [3]u8, @as(*const [3]u8, src_ptr85), 0, 3, src_ptr85[0..3]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr85), 0, 1, src_ptr85[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr85), 0, dest_end, src_ptr85[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr85), 0, dest_end, src_ptr85[0..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr85), 0, 2, src_ptr85[0..][0..2]); + vl(*const [3]u8, @as(*const [3]u8, src_ptr85), 0, 3, src_ptr85[0..][0..3]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr85), 0, 1, src_ptr85[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [3]u8, src_ptr85), 0, dest_len, src_ptr85[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [3]u8, src_ptr85), 0, dest_len, src_ptr85[0..][0..dest_len]); + vs(*const [2]u8, @as(*const [3]u8, src_ptr85), 1, src_ptr85[1..]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr85), 1, 2, src_ptr85[1..2]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr85), 1, 3, src_ptr85[1..3]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr85), 1, 1, src_ptr85[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr85), 1, dest_end, src_ptr85[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr85), 1, dest_end, src_ptr85[1..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr85), 1, 2, src_ptr85[1..][0..2]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr85), 1, 1, src_ptr85[1..][0..1]); + vl([]const u8, @as(*const [3]u8, src_ptr85), 1, dest_len, src_ptr85[1..][0..dest_len]); + vs(*const [0]u8, @as(*const [3]u8, src_ptr85), 3, src_ptr85[3..]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr85), 3, 3, src_ptr85[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr85), 3, dest_end, src_ptr85[3..dest_end]); + var src_ptr86: *const [2:0]u8 = src_mem21[0..2 :0]; + vs(*const [2:0]u8, @as(*const [2:0]u8, src_ptr86), 0, src_ptr86[0..]); + ve(*const [2:0]u8, @as(*const [2:0]u8, src_ptr86), 0, 2, src_ptr86[0..2]); + ve(*const [3]u8, @as(*const [2:0]u8, src_ptr86), 0, 3, src_ptr86[0..3]); + ve(*const [1]u8, @as(*const [2:0]u8, src_ptr86), 0, 1, src_ptr86[0..1]); + ve([]const u8, @as(*const [2:0]u8, src_ptr86), 0, dest_end, src_ptr86[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr86), 0, dest_end, src_ptr86[0..dest_end]); + vl(*const [2:0]u8, @as(*const [2:0]u8, src_ptr86), 0, 2, src_ptr86[0..][0..2]); + vl(*const [3]u8, @as(*const [2:0]u8, src_ptr86), 0, 3, src_ptr86[0..][0..3]); + vl(*const [1]u8, @as(*const [2:0]u8, src_ptr86), 0, 1, src_ptr86[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [2:0]u8, src_ptr86), 0, dest_len, src_ptr86[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [2:0]u8, src_ptr86), 0, dest_len, src_ptr86[0..][0..dest_len]); + vs(*const [1:0]u8, @as(*const [2:0]u8, src_ptr86), 1, src_ptr86[1..]); + ve(*const [1:0]u8, @as(*const [2:0]u8, src_ptr86), 1, 2, src_ptr86[1..2]); + ve(*const [2]u8, @as(*const [2:0]u8, src_ptr86), 1, 3, src_ptr86[1..3]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr86), 1, 1, src_ptr86[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr86), 1, dest_end, src_ptr86[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr86), 1, dest_end, src_ptr86[1..dest_end]); + vl(*const [2]u8, @as(*const [2:0]u8, src_ptr86), 1, 2, src_ptr86[1..][0..2]); + vl(*const [1:0]u8, @as(*const [2:0]u8, src_ptr86), 1, 1, src_ptr86[1..][0..1]); + vl([]const u8, @as(*const [2:0]u8, src_ptr86), 1, dest_len, src_ptr86[1..][0..dest_len]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr86), 3, 3, src_ptr86[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr86), 3, dest_end, src_ptr86[3..dest_end]); + var src_ptr87: *const [1]u8 = src_mem22[0..1]; + vs(*const [1]u8, @as(*const [1]u8, src_ptr87), 0, src_ptr87[0..]); + ve(*const [1]u8, @as(*const [1]u8, src_ptr87), 0, 1, src_ptr87[0..1]); + dest_end = 1; + ve([]const u8, @as(*const [1]u8, src_ptr87), 0, dest_end, src_ptr87[0..dest_end]); + vl(*const [1]u8, @as(*const [1]u8, src_ptr87), 0, 1, src_ptr87[0..][0..1]); + vl([]const u8, @as(*const [1]u8, src_ptr87), 0, dest_len, src_ptr87[0..][0..dest_len]); + vs(*const [0]u8, @as(*const [1]u8, src_ptr87), 1, src_ptr87[1..]); + ve(*const [0]u8, @as(*const [1]u8, src_ptr87), 1, 1, src_ptr87[1..1]); + ve([]const u8, @as(*const [1]u8, src_ptr87), 1, dest_end, src_ptr87[1..dest_end]); + var src_ptr88: *const [0:0]u8 = src_mem23[0..0 :0]; + vs(*const [0:0]u8, @as(*const [0:0]u8, src_ptr88), 0, src_ptr88[0..]); + ve(*const [1]u8, @as(*const [0:0]u8, src_ptr88), 0, 1, src_ptr88[0..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr88), 0, dest_end, src_ptr88[0..dest_end]); + vl(*const [1]u8, @as(*const [0:0]u8, src_ptr88), 0, 1, src_ptr88[0..][0..1]); + vl([]const u8, @as(*const [0:0]u8, src_ptr88), 0, dest_len, src_ptr88[0..][0..dest_len]); + ve(*const [0]u8, @as(*const [0:0]u8, src_ptr88), 1, 1, src_ptr88[1..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr88), 1, dest_end, src_ptr88[1..dest_end]); + const src_ptr89: []const u8 = src_mem18[0..2]; + vs(*const [2]u8, @as([]const u8, src_ptr89), 0, src_ptr89[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr89), 0, 2, src_ptr89[0..2]); + ve(*const [1]u8, @as([]const u8, src_ptr89), 0, 1, src_ptr89[0..1]); + ve([]const u8, @as([]const u8, src_ptr89), 0, dest_end, src_ptr89[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr89), 0, 2, src_ptr89[0..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr89), 0, 1, src_ptr89[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr89), 0, dest_len, src_ptr89[0..][0..dest_len]); + vs(*const [1]u8, @as([]const u8, src_ptr89), 1, src_ptr89[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr89), 1, 2, src_ptr89[1..2]); + ve(*const [0]u8, @as([]const u8, src_ptr89), 1, 1, src_ptr89[1..1]); + ve([]const u8, @as([]const u8, src_ptr89), 1, dest_end, src_ptr89[1..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr89), 1, 1, src_ptr89[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr89), 1, dest_len, src_ptr89[1..][0..dest_len]); + const src_ptr90: [:0]const u8 = src_mem19[0..1 :0]; + vs(*const [1:0]u8, @as([:0]const u8, src_ptr90), 0, src_ptr90[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr90), 0, 2, src_ptr90[0..2]); + ve(*const [1:0]u8, @as([:0]const u8, src_ptr90), 0, 1, src_ptr90[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr90), 0, dest_end, src_ptr90[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr90), 0, 2, src_ptr90[0..][0..2]); + vl(*const [1:0]u8, @as([:0]const u8, src_ptr90), 0, 1, src_ptr90[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr90), 0, dest_len, src_ptr90[0..][0..dest_len]); + vs(*const [0:0]u8, @as([:0]const u8, src_ptr90), 1, src_ptr90[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr90), 1, 2, src_ptr90[1..2]); + ve(*const [0:0]u8, @as([:0]const u8, src_ptr90), 1, 1, src_ptr90[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr90), 1, dest_end, src_ptr90[1..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr90), 1, 1, src_ptr90[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr90), 1, dest_len, src_ptr90[1..][0..dest_len]); + const src_ptr91: []const u8 = src_mem20[0..3]; + vs(*const [3]u8, @as([]const u8, src_ptr91), 0, src_ptr91[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr91), 0, 2, src_ptr91[0..2]); + ve(*const [3]u8, @as([]const u8, src_ptr91), 0, 3, src_ptr91[0..3]); + ve(*const [1]u8, @as([]const u8, src_ptr91), 0, 1, src_ptr91[0..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr91), 0, dest_end, src_ptr91[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr91), 0, dest_end, src_ptr91[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr91), 0, 2, src_ptr91[0..][0..2]); + vl(*const [3]u8, @as([]const u8, src_ptr91), 0, 3, src_ptr91[0..][0..3]); + vl(*const [1]u8, @as([]const u8, src_ptr91), 0, 1, src_ptr91[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([]const u8, src_ptr91), 0, dest_len, src_ptr91[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([]const u8, src_ptr91), 0, dest_len, src_ptr91[0..][0..dest_len]); + vs(*const [2]u8, @as([]const u8, src_ptr91), 1, src_ptr91[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr91), 1, 2, src_ptr91[1..2]); + ve(*const [2]u8, @as([]const u8, src_ptr91), 1, 3, src_ptr91[1..3]); + ve(*const [0]u8, @as([]const u8, src_ptr91), 1, 1, src_ptr91[1..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr91), 1, dest_end, src_ptr91[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr91), 1, dest_end, src_ptr91[1..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr91), 1, 2, src_ptr91[1..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr91), 1, 1, src_ptr91[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr91), 1, dest_len, src_ptr91[1..][0..dest_len]); + vs(*const [0]u8, @as([]const u8, src_ptr91), 3, src_ptr91[3..]); + ve(*const [0]u8, @as([]const u8, src_ptr91), 3, 3, src_ptr91[3..3]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr91), 3, dest_end, src_ptr91[3..dest_end]); + const src_ptr92: [:0]const u8 = src_mem21[0..2 :0]; + vs(*const [2:0]u8, @as([:0]const u8, src_ptr92), 0, src_ptr92[0..]); + ve(*const [2:0]u8, @as([:0]const u8, src_ptr92), 0, 2, src_ptr92[0..2]); + ve(*const [3]u8, @as([:0]const u8, src_ptr92), 0, 3, src_ptr92[0..3]); + ve(*const [1]u8, @as([:0]const u8, src_ptr92), 0, 1, src_ptr92[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr92), 0, dest_end, src_ptr92[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr92), 0, dest_end, src_ptr92[0..dest_end]); + vl(*const [2:0]u8, @as([:0]const u8, src_ptr92), 0, 2, src_ptr92[0..][0..2]); + vl(*const [3]u8, @as([:0]const u8, src_ptr92), 0, 3, src_ptr92[0..][0..3]); + vl(*const [1]u8, @as([:0]const u8, src_ptr92), 0, 1, src_ptr92[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([:0]const u8, src_ptr92), 0, dest_len, src_ptr92[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([:0]const u8, src_ptr92), 0, dest_len, src_ptr92[0..][0..dest_len]); + vs(*const [1:0]u8, @as([:0]const u8, src_ptr92), 1, src_ptr92[1..]); + ve(*const [1:0]u8, @as([:0]const u8, src_ptr92), 1, 2, src_ptr92[1..2]); + ve(*const [2]u8, @as([:0]const u8, src_ptr92), 1, 3, src_ptr92[1..3]); + ve(*const [0]u8, @as([:0]const u8, src_ptr92), 1, 1, src_ptr92[1..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr92), 1, dest_end, src_ptr92[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr92), 1, dest_end, src_ptr92[1..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr92), 1, 2, src_ptr92[1..][0..2]); + vl(*const [1:0]u8, @as([:0]const u8, src_ptr92), 1, 1, src_ptr92[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr92), 1, dest_len, src_ptr92[1..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr92), 3, 3, src_ptr92[3..3]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr92), 3, dest_end, src_ptr92[3..dest_end]); + const src_ptr93: []const u8 = src_mem22[0..1]; + vs(*const [1]u8, @as([]const u8, src_ptr93), 0, src_ptr93[0..]); + ve(*const [1]u8, @as([]const u8, src_ptr93), 0, 1, src_ptr93[0..1]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr93), 0, dest_end, src_ptr93[0..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr93), 0, 1, src_ptr93[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr93), 0, dest_len, src_ptr93[0..][0..dest_len]); + vs(*const [0]u8, @as([]const u8, src_ptr93), 1, src_ptr93[1..]); + ve(*const [0]u8, @as([]const u8, src_ptr93), 1, 1, src_ptr93[1..1]); + ve([]const u8, @as([]const u8, src_ptr93), 1, dest_end, src_ptr93[1..dest_end]); + const src_ptr94: [:0]const u8 = src_mem23[0..0 :0]; + vs(*const [0:0]u8, @as([:0]const u8, src_ptr94), 0, src_ptr94[0..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr94), 0, 1, src_ptr94[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr94), 0, dest_end, src_ptr94[0..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr94), 0, 1, src_ptr94[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr94), 0, dest_len, src_ptr94[0..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr94), 1, 1, src_ptr94[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr94), 1, dest_end, src_ptr94[1..dest_end]); + var src_ptr95: []const u8 = src_mem18[0..2]; + vs([]const u8, @as([]const u8, src_ptr95), 0, src_ptr95[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr95), 0, 2, src_ptr95[0..2]); + ve(*const [1]u8, @as([]const u8, src_ptr95), 0, 1, src_ptr95[0..1]); + ve([]const u8, @as([]const u8, src_ptr95), 0, dest_end, src_ptr95[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr95), 0, 2, src_ptr95[0..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr95), 0, 1, src_ptr95[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr95), 0, dest_len, src_ptr95[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr95), 1, src_ptr95[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr95), 1, 2, src_ptr95[1..2]); + ve(*const [0]u8, @as([]const u8, src_ptr95), 1, 1, src_ptr95[1..1]); + ve([]const u8, @as([]const u8, src_ptr95), 1, dest_end, src_ptr95[1..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr95), 1, 1, src_ptr95[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr95), 1, dest_len, src_ptr95[1..][0..dest_len]); + var src_ptr96: [:0]const u8 = src_mem19[0..1 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr96), 0, src_ptr96[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr96), 0, 2, src_ptr96[0..2]); + ve(*const [1]u8, @as([:0]const u8, src_ptr96), 0, 1, src_ptr96[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr96), 0, dest_end, src_ptr96[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr96), 0, 2, src_ptr96[0..][0..2]); + vl(*const [1]u8, @as([:0]const u8, src_ptr96), 0, 1, src_ptr96[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr96), 0, dest_len, src_ptr96[0..][0..dest_len]); + vs([:0]const u8, @as([:0]const u8, src_ptr96), 1, src_ptr96[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr96), 1, 2, src_ptr96[1..2]); + ve(*const [0]u8, @as([:0]const u8, src_ptr96), 1, 1, src_ptr96[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr96), 1, dest_end, src_ptr96[1..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr96), 1, 1, src_ptr96[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr96), 1, dest_len, src_ptr96[1..][0..dest_len]); + var src_ptr97: []const u8 = src_mem20[0..3]; + vs([]const u8, @as([]const u8, src_ptr97), 0, src_ptr97[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr97), 0, 2, src_ptr97[0..2]); + ve(*const [3]u8, @as([]const u8, src_ptr97), 0, 3, src_ptr97[0..3]); + ve(*const [1]u8, @as([]const u8, src_ptr97), 0, 1, src_ptr97[0..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr97), 0, dest_end, src_ptr97[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr97), 0, dest_end, src_ptr97[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr97), 0, 2, src_ptr97[0..][0..2]); + vl(*const [3]u8, @as([]const u8, src_ptr97), 0, 3, src_ptr97[0..][0..3]); + vl(*const [1]u8, @as([]const u8, src_ptr97), 0, 1, src_ptr97[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([]const u8, src_ptr97), 0, dest_len, src_ptr97[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([]const u8, src_ptr97), 0, dest_len, src_ptr97[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr97), 1, src_ptr97[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr97), 1, 2, src_ptr97[1..2]); + ve(*const [2]u8, @as([]const u8, src_ptr97), 1, 3, src_ptr97[1..3]); + ve(*const [0]u8, @as([]const u8, src_ptr97), 1, 1, src_ptr97[1..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr97), 1, dest_end, src_ptr97[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr97), 1, dest_end, src_ptr97[1..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr97), 1, 2, src_ptr97[1..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr97), 1, 1, src_ptr97[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr97), 1, dest_len, src_ptr97[1..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr97), 3, src_ptr97[3..]); + ve(*const [0]u8, @as([]const u8, src_ptr97), 3, 3, src_ptr97[3..3]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr97), 3, dest_end, src_ptr97[3..dest_end]); + var src_ptr98: [:0]const u8 = src_mem21[0..2 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr98), 0, src_ptr98[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr98), 0, 2, src_ptr98[0..2]); + ve(*const [3]u8, @as([:0]const u8, src_ptr98), 0, 3, src_ptr98[0..3]); + ve(*const [1]u8, @as([:0]const u8, src_ptr98), 0, 1, src_ptr98[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr98), 0, dest_end, src_ptr98[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr98), 0, dest_end, src_ptr98[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr98), 0, 2, src_ptr98[0..][0..2]); + vl(*const [3]u8, @as([:0]const u8, src_ptr98), 0, 3, src_ptr98[0..][0..3]); + vl(*const [1]u8, @as([:0]const u8, src_ptr98), 0, 1, src_ptr98[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([:0]const u8, src_ptr98), 0, dest_len, src_ptr98[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([:0]const u8, src_ptr98), 0, dest_len, src_ptr98[0..][0..dest_len]); + vs([:0]const u8, @as([:0]const u8, src_ptr98), 1, src_ptr98[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr98), 1, 2, src_ptr98[1..2]); + ve(*const [2]u8, @as([:0]const u8, src_ptr98), 1, 3, src_ptr98[1..3]); + ve(*const [0]u8, @as([:0]const u8, src_ptr98), 1, 1, src_ptr98[1..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr98), 1, dest_end, src_ptr98[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr98), 1, dest_end, src_ptr98[1..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr98), 1, 2, src_ptr98[1..][0..2]); + vl(*const [1]u8, @as([:0]const u8, src_ptr98), 1, 1, src_ptr98[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr98), 1, dest_len, src_ptr98[1..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr98), 3, 3, src_ptr98[3..3]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr98), 3, dest_end, src_ptr98[3..dest_end]); + var src_ptr99: []const u8 = src_mem22[0..1]; + vs([]const u8, @as([]const u8, src_ptr99), 0, src_ptr99[0..]); + ve(*const [1]u8, @as([]const u8, src_ptr99), 0, 1, src_ptr99[0..1]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr99), 0, dest_end, src_ptr99[0..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr99), 0, 1, src_ptr99[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr99), 0, dest_len, src_ptr99[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr99), 1, src_ptr99[1..]); + ve(*const [0]u8, @as([]const u8, src_ptr99), 1, 1, src_ptr99[1..1]); + ve([]const u8, @as([]const u8, src_ptr99), 1, dest_end, src_ptr99[1..dest_end]); + var src_ptr100: [:0]const u8 = src_mem23[0..0 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr100), 0, src_ptr100[0..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr100), 0, 1, src_ptr100[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr100), 0, dest_end, src_ptr100[0..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr100), 0, 1, src_ptr100[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr100), 0, dest_len, src_ptr100[0..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr100), 1, 1, src_ptr100[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr100), 1, dest_end, src_ptr100[1..dest_end]); + const src_ptr101: [*]const u8 = @ptrCast(&src_mem18); + vs([*]const u8, @as([*]const u8, src_ptr101), 0, src_ptr101[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr101), 0, 2, src_ptr101[0..2]); + ve(*const [1]u8, @as([*]const u8, src_ptr101), 0, 1, src_ptr101[0..1]); + ve([]const u8, @as([*]const u8, src_ptr101), 0, dest_end, src_ptr101[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr101), 0, 2, src_ptr101[0..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr101), 0, 1, src_ptr101[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr101), 0, dest_len, src_ptr101[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr101), 1, src_ptr101[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr101), 1, 2, src_ptr101[1..2]); + ve(*const [0]u8, @as([*]const u8, src_ptr101), 1, 1, src_ptr101[1..1]); + ve([]const u8, @as([*]const u8, src_ptr101), 1, dest_end, src_ptr101[1..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr101), 1, 1, src_ptr101[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr101), 1, dest_len, src_ptr101[1..][0..dest_len]); + vs([*:1]const u8, @as([*]const u8, src_ptr101), 0, src_ptr101[0.. :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr101), 1, src_ptr101[1.. :1]); + const src_ptr102: [*:0]const u8 = @ptrCast(&src_mem19); + vs([*]const u8, @as([*:0]const u8, src_ptr102), 0, src_ptr102[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr102), 0, 2, src_ptr102[0..2]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr102), 0, 1, src_ptr102[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr102), 0, dest_end, src_ptr102[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr102), 0, 2, src_ptr102[0..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr102), 0, 1, src_ptr102[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr102), 0, dest_len, src_ptr102[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr102), 1, src_ptr102[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr102), 1, 2, src_ptr102[1..2]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr102), 1, 1, src_ptr102[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr102), 1, dest_end, src_ptr102[1..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr102), 1, 1, src_ptr102[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr102), 1, dest_len, src_ptr102[1..][0..dest_len]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr102), 0, src_ptr102[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr102), 1, src_ptr102[1.. :1]); + const src_ptr103: [*]const u8 = @ptrCast(&src_mem20); + vs([*]const u8, @as([*]const u8, src_ptr103), 0, src_ptr103[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr103), 0, 2, src_ptr103[0..2]); + ve(*const [3]u8, @as([*]const u8, src_ptr103), 0, 3, src_ptr103[0..3]); + ve(*const [1]u8, @as([*]const u8, src_ptr103), 0, 1, src_ptr103[0..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr103), 0, dest_end, src_ptr103[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr103), 0, dest_end, src_ptr103[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr103), 0, 2, src_ptr103[0..][0..2]); + vl(*const [3]u8, @as([*]const u8, src_ptr103), 0, 3, src_ptr103[0..][0..3]); + vl(*const [1]u8, @as([*]const u8, src_ptr103), 0, 1, src_ptr103[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*]const u8, src_ptr103), 0, dest_len, src_ptr103[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*]const u8, src_ptr103), 0, dest_len, src_ptr103[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr103), 1, src_ptr103[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr103), 1, 2, src_ptr103[1..2]); + ve(*const [2]u8, @as([*]const u8, src_ptr103), 1, 3, src_ptr103[1..3]); + ve(*const [0]u8, @as([*]const u8, src_ptr103), 1, 1, src_ptr103[1..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr103), 1, dest_end, src_ptr103[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr103), 1, dest_end, src_ptr103[1..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr103), 1, 2, src_ptr103[1..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr103), 1, 1, src_ptr103[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr103), 1, dest_len, src_ptr103[1..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr103), 3, src_ptr103[3..]); + ve(*const [0]u8, @as([*]const u8, src_ptr103), 3, 3, src_ptr103[3..3]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr103), 3, dest_end, src_ptr103[3..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr103), 0, src_ptr103[0.. :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr103), 1, src_ptr103[1.. :1]); + const src_ptr104: [*:0]const u8 = @ptrCast(&src_mem21); + vs([*]const u8, @as([*:0]const u8, src_ptr104), 0, src_ptr104[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr104), 0, 2, src_ptr104[0..2]); + ve(*const [3]u8, @as([*:0]const u8, src_ptr104), 0, 3, src_ptr104[0..3]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr104), 0, 1, src_ptr104[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr104), 0, dest_end, src_ptr104[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr104), 0, dest_end, src_ptr104[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr104), 0, 2, src_ptr104[0..][0..2]); + vl(*const [3]u8, @as([*:0]const u8, src_ptr104), 0, 3, src_ptr104[0..][0..3]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr104), 0, 1, src_ptr104[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*:0]const u8, src_ptr104), 0, dest_len, src_ptr104[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*:0]const u8, src_ptr104), 0, dest_len, src_ptr104[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr104), 1, src_ptr104[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr104), 1, 2, src_ptr104[1..2]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr104), 1, 3, src_ptr104[1..3]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr104), 1, 1, src_ptr104[1..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr104), 1, dest_end, src_ptr104[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr104), 1, dest_end, src_ptr104[1..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr104), 1, 2, src_ptr104[1..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr104), 1, 1, src_ptr104[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr104), 1, dest_len, src_ptr104[1..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr104), 3, src_ptr104[3..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr104), 3, 3, src_ptr104[3..3]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr104), 3, dest_end, src_ptr104[3..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr104), 0, src_ptr104[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr104), 1, src_ptr104[1.. :1]); + const src_ptr105: [*]const u8 = @ptrCast(&src_mem22); + vs([*]const u8, @as([*]const u8, src_ptr105), 0, src_ptr105[0..]); + ve(*const [1]u8, @as([*]const u8, src_ptr105), 0, 1, src_ptr105[0..1]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr105), 0, dest_end, src_ptr105[0..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr105), 0, 1, src_ptr105[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr105), 0, dest_len, src_ptr105[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr105), 1, src_ptr105[1..]); + ve(*const [0]u8, @as([*]const u8, src_ptr105), 1, 1, src_ptr105[1..1]); + ve([]const u8, @as([*]const u8, src_ptr105), 1, dest_end, src_ptr105[1..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr105), 0, src_ptr105[0.. :1]); + const src_ptr106: [*:0]const u8 = @ptrCast(&src_mem23); + vs([*]const u8, @as([*:0]const u8, src_ptr106), 0, src_ptr106[0..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr106), 0, 1, src_ptr106[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr106), 0, dest_end, src_ptr106[0..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr106), 0, 1, src_ptr106[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr106), 0, dest_len, src_ptr106[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr106), 1, src_ptr106[1..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr106), 1, 1, src_ptr106[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr106), 1, dest_end, src_ptr106[1..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr106), 0, src_ptr106[0.. :1]); + var src_ptr107: [*]const u8 = @ptrCast(&src_mem18); + vs([*]const u8, @as([*]const u8, src_ptr107), 0, src_ptr107[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr107), 0, 2, src_ptr107[0..2]); + ve(*const [1]u8, @as([*]const u8, src_ptr107), 0, 1, src_ptr107[0..1]); + ve([]const u8, @as([*]const u8, src_ptr107), 0, dest_end, src_ptr107[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr107), 0, 2, src_ptr107[0..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr107), 0, 1, src_ptr107[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr107), 0, dest_len, src_ptr107[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr107), 1, src_ptr107[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr107), 1, 2, src_ptr107[1..2]); + ve(*const [0]u8, @as([*]const u8, src_ptr107), 1, 1, src_ptr107[1..1]); + ve([]const u8, @as([*]const u8, src_ptr107), 1, dest_end, src_ptr107[1..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr107), 1, 1, src_ptr107[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr107), 1, dest_len, src_ptr107[1..][0..dest_len]); + vs([*:1]const u8, @as([*]const u8, src_ptr107), 0, src_ptr107[0.. :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr107), 1, src_ptr107[1.. :1]); + var src_ptr108: [*:0]const u8 = @ptrCast(&src_mem19); + vs([*]const u8, @as([*:0]const u8, src_ptr108), 0, src_ptr108[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr108), 0, 2, src_ptr108[0..2]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr108), 0, 1, src_ptr108[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr108), 0, dest_end, src_ptr108[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr108), 0, 2, src_ptr108[0..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr108), 0, 1, src_ptr108[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr108), 0, dest_len, src_ptr108[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr108), 1, src_ptr108[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr108), 1, 2, src_ptr108[1..2]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr108), 1, 1, src_ptr108[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr108), 1, dest_end, src_ptr108[1..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr108), 1, 1, src_ptr108[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr108), 1, dest_len, src_ptr108[1..][0..dest_len]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr108), 0, src_ptr108[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr108), 1, src_ptr108[1.. :1]); + var src_ptr109: [*]const u8 = @ptrCast(&src_mem20); + vs([*]const u8, @as([*]const u8, src_ptr109), 0, src_ptr109[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr109), 0, 2, src_ptr109[0..2]); + ve(*const [3]u8, @as([*]const u8, src_ptr109), 0, 3, src_ptr109[0..3]); + ve(*const [1]u8, @as([*]const u8, src_ptr109), 0, 1, src_ptr109[0..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr109), 0, dest_end, src_ptr109[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr109), 0, dest_end, src_ptr109[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr109), 0, 2, src_ptr109[0..][0..2]); + vl(*const [3]u8, @as([*]const u8, src_ptr109), 0, 3, src_ptr109[0..][0..3]); + vl(*const [1]u8, @as([*]const u8, src_ptr109), 0, 1, src_ptr109[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*]const u8, src_ptr109), 0, dest_len, src_ptr109[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*]const u8, src_ptr109), 0, dest_len, src_ptr109[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr109), 1, src_ptr109[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr109), 1, 2, src_ptr109[1..2]); + ve(*const [2]u8, @as([*]const u8, src_ptr109), 1, 3, src_ptr109[1..3]); + ve(*const [0]u8, @as([*]const u8, src_ptr109), 1, 1, src_ptr109[1..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr109), 1, dest_end, src_ptr109[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr109), 1, dest_end, src_ptr109[1..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr109), 1, 2, src_ptr109[1..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr109), 1, 1, src_ptr109[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr109), 1, dest_len, src_ptr109[1..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr109), 3, src_ptr109[3..]); + ve(*const [0]u8, @as([*]const u8, src_ptr109), 3, 3, src_ptr109[3..3]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr109), 3, dest_end, src_ptr109[3..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr109), 0, src_ptr109[0.. :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr109), 1, src_ptr109[1.. :1]); + var src_ptr110: [*:0]const u8 = @ptrCast(&src_mem21); + vs([*]const u8, @as([*:0]const u8, src_ptr110), 0, src_ptr110[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr110), 0, 2, src_ptr110[0..2]); + ve(*const [3]u8, @as([*:0]const u8, src_ptr110), 0, 3, src_ptr110[0..3]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr110), 0, 1, src_ptr110[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr110), 0, dest_end, src_ptr110[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr110), 0, dest_end, src_ptr110[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr110), 0, 2, src_ptr110[0..][0..2]); + vl(*const [3]u8, @as([*:0]const u8, src_ptr110), 0, 3, src_ptr110[0..][0..3]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr110), 0, 1, src_ptr110[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*:0]const u8, src_ptr110), 0, dest_len, src_ptr110[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*:0]const u8, src_ptr110), 0, dest_len, src_ptr110[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr110), 1, src_ptr110[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr110), 1, 2, src_ptr110[1..2]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr110), 1, 3, src_ptr110[1..3]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr110), 1, 1, src_ptr110[1..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr110), 1, dest_end, src_ptr110[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr110), 1, dest_end, src_ptr110[1..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr110), 1, 2, src_ptr110[1..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr110), 1, 1, src_ptr110[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr110), 1, dest_len, src_ptr110[1..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr110), 3, src_ptr110[3..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr110), 3, 3, src_ptr110[3..3]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr110), 3, dest_end, src_ptr110[3..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr110), 0, src_ptr110[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr110), 1, src_ptr110[1.. :1]); + var src_ptr111: [*]const u8 = @ptrCast(&src_mem22); + vs([*]const u8, @as([*]const u8, src_ptr111), 0, src_ptr111[0..]); + ve(*const [1]u8, @as([*]const u8, src_ptr111), 0, 1, src_ptr111[0..1]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr111), 0, dest_end, src_ptr111[0..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr111), 0, 1, src_ptr111[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr111), 0, dest_len, src_ptr111[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr111), 1, src_ptr111[1..]); + ve(*const [0]u8, @as([*]const u8, src_ptr111), 1, 1, src_ptr111[1..1]); + ve([]const u8, @as([*]const u8, src_ptr111), 1, dest_end, src_ptr111[1..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr111), 0, src_ptr111[0.. :1]); + var src_ptr112: [*:0]const u8 = @ptrCast(&src_mem23); + vs([*]const u8, @as([*:0]const u8, src_ptr112), 0, src_ptr112[0..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr112), 0, 1, src_ptr112[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr112), 0, dest_end, src_ptr112[0..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr112), 0, 1, src_ptr112[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr112), 0, dest_len, src_ptr112[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr112), 1, src_ptr112[1..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr112), 1, 1, src_ptr112[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr112), 1, dest_end, src_ptr112[1..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr112), 0, src_ptr112[0.. :1]); + const src_ptr113: [*c]const u8 = @ptrCast(&src_mem18); + vs([*c]const u8, @as([*c]const u8, src_ptr113), 0, src_ptr113[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr113), 0, 2, src_ptr113[0..2]); + ve(*const [1]u8, @as([*c]const u8, src_ptr113), 0, 1, src_ptr113[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr113), 0, dest_end, src_ptr113[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr113), 0, 2, src_ptr113[0..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr113), 0, 1, src_ptr113[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr113), 0, dest_len, src_ptr113[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr113), 1, src_ptr113[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr113), 1, 2, src_ptr113[1..2]); + ve(*const [0]u8, @as([*c]const u8, src_ptr113), 1, 1, src_ptr113[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr113), 1, dest_end, src_ptr113[1..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr113), 1, 1, src_ptr113[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr113), 1, dest_len, src_ptr113[1..][0..dest_len]); + vs([*:1]const u8, @as([*c]const u8, src_ptr113), 0, src_ptr113[0.. :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr113), 1, src_ptr113[1.. :1]); + const src_ptr114: [*c]const u8 = @ptrCast(&src_mem20); + vs([*c]const u8, @as([*c]const u8, src_ptr114), 0, src_ptr114[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr114), 0, 2, src_ptr114[0..2]); + ve(*const [3]u8, @as([*c]const u8, src_ptr114), 0, 3, src_ptr114[0..3]); + ve(*const [1]u8, @as([*c]const u8, src_ptr114), 0, 1, src_ptr114[0..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr114), 0, dest_end, src_ptr114[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr114), 0, dest_end, src_ptr114[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr114), 0, 2, src_ptr114[0..][0..2]); + vl(*const [3]u8, @as([*c]const u8, src_ptr114), 0, 3, src_ptr114[0..][0..3]); + vl(*const [1]u8, @as([*c]const u8, src_ptr114), 0, 1, src_ptr114[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*c]const u8, src_ptr114), 0, dest_len, src_ptr114[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*c]const u8, src_ptr114), 0, dest_len, src_ptr114[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr114), 1, src_ptr114[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr114), 1, 2, src_ptr114[1..2]); + ve(*const [2]u8, @as([*c]const u8, src_ptr114), 1, 3, src_ptr114[1..3]); + ve(*const [0]u8, @as([*c]const u8, src_ptr114), 1, 1, src_ptr114[1..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr114), 1, dest_end, src_ptr114[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr114), 1, dest_end, src_ptr114[1..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr114), 1, 2, src_ptr114[1..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr114), 1, 1, src_ptr114[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr114), 1, dest_len, src_ptr114[1..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr114), 3, src_ptr114[3..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr114), 3, 3, src_ptr114[3..3]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr114), 3, dest_end, src_ptr114[3..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr114), 0, src_ptr114[0.. :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr114), 1, src_ptr114[1.. :1]); + const src_ptr115: [*c]const u8 = @ptrCast(&src_mem22); + vs([*c]const u8, @as([*c]const u8, src_ptr115), 0, src_ptr115[0..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr115), 0, 1, src_ptr115[0..1]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr115), 0, dest_end, src_ptr115[0..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr115), 0, 1, src_ptr115[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr115), 0, dest_len, src_ptr115[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr115), 1, src_ptr115[1..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr115), 1, 1, src_ptr115[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr115), 1, dest_end, src_ptr115[1..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr115), 0, src_ptr115[0.. :1]); + var src_ptr116: [*c]const u8 = @ptrCast(&src_mem18); + vs([*c]const u8, @as([*c]const u8, src_ptr116), 0, src_ptr116[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr116), 0, 2, src_ptr116[0..2]); + ve(*const [1]u8, @as([*c]const u8, src_ptr116), 0, 1, src_ptr116[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr116), 0, dest_end, src_ptr116[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr116), 0, 2, src_ptr116[0..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr116), 0, 1, src_ptr116[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr116), 0, dest_len, src_ptr116[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr116), 1, src_ptr116[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr116), 1, 2, src_ptr116[1..2]); + ve(*const [0]u8, @as([*c]const u8, src_ptr116), 1, 1, src_ptr116[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr116), 1, dest_end, src_ptr116[1..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr116), 1, 1, src_ptr116[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr116), 1, dest_len, src_ptr116[1..][0..dest_len]); + vs([*:1]const u8, @as([*c]const u8, src_ptr116), 0, src_ptr116[0.. :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr116), 1, src_ptr116[1.. :1]); + var src_ptr117: [*c]const u8 = @ptrCast(&src_mem20); + vs([*c]const u8, @as([*c]const u8, src_ptr117), 0, src_ptr117[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr117), 0, 2, src_ptr117[0..2]); + ve(*const [3]u8, @as([*c]const u8, src_ptr117), 0, 3, src_ptr117[0..3]); + ve(*const [1]u8, @as([*c]const u8, src_ptr117), 0, 1, src_ptr117[0..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr117), 0, dest_end, src_ptr117[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr117), 0, dest_end, src_ptr117[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr117), 0, 2, src_ptr117[0..][0..2]); + vl(*const [3]u8, @as([*c]const u8, src_ptr117), 0, 3, src_ptr117[0..][0..3]); + vl(*const [1]u8, @as([*c]const u8, src_ptr117), 0, 1, src_ptr117[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*c]const u8, src_ptr117), 0, dest_len, src_ptr117[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*c]const u8, src_ptr117), 0, dest_len, src_ptr117[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr117), 1, src_ptr117[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr117), 1, 2, src_ptr117[1..2]); + ve(*const [2]u8, @as([*c]const u8, src_ptr117), 1, 3, src_ptr117[1..3]); + ve(*const [0]u8, @as([*c]const u8, src_ptr117), 1, 1, src_ptr117[1..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr117), 1, dest_end, src_ptr117[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr117), 1, dest_end, src_ptr117[1..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr117), 1, 2, src_ptr117[1..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr117), 1, 1, src_ptr117[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr117), 1, dest_len, src_ptr117[1..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr117), 3, src_ptr117[3..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr117), 3, 3, src_ptr117[3..3]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr117), 3, dest_end, src_ptr117[3..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr117), 0, src_ptr117[0.. :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr117), 1, src_ptr117[1.. :1]); + var src_ptr118: [*c]const u8 = @ptrCast(&src_mem22); + vs([*c]const u8, @as([*c]const u8, src_ptr118), 0, src_ptr118[0..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr118), 0, 1, src_ptr118[0..1]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr118), 0, dest_end, src_ptr118[0..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr118), 0, 1, src_ptr118[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr118), 0, dest_len, src_ptr118[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr118), 1, src_ptr118[1..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr118), 1, 1, src_ptr118[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr118), 1, dest_end, src_ptr118[1..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr118), 0, src_ptr118[0.. :1]); + const src_mem24: [2]u8 = .{ 1, 1 }; + const src_ptr119: *const [2]u8 = src_mem24[0..2]; + vs(*const [2]u8, @as(*const [2]u8, src_ptr119), 0, src_ptr119[0..]); + ve(*const [2]u8, @as(*const [2]u8, src_ptr119), 0, 2, src_ptr119[0..2]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr119), 0, 1, src_ptr119[0..1]); + ve([]const u8, @as(*const [2]u8, src_ptr119), 0, dest_end, src_ptr119[0..dest_end]); + vl(*const [2]u8, @as(*const [2]u8, src_ptr119), 0, 2, src_ptr119[0..][0..2]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr119), 0, 1, src_ptr119[0..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr119), 0, dest_len, src_ptr119[0..][0..dest_len]); + vs(*const [1]u8, @as(*const [2]u8, src_ptr119), 1, src_ptr119[1..]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr119), 1, 2, src_ptr119[1..2]); + ve(*const [0]u8, @as(*const [2]u8, src_ptr119), 1, 1, src_ptr119[1..1]); + ve([]const u8, @as(*const [2]u8, src_ptr119), 1, dest_end, src_ptr119[1..dest_end]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr119), 1, 1, src_ptr119[1..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr119), 1, dest_len, src_ptr119[1..][0..dest_len]); + ve(*const [1:1]u8, @as(*const [2]u8, src_ptr119), 0, 1, src_ptr119[0..1 :1]); + ve([:1]const u8, @as(*const [2]u8, src_ptr119), 0, dest_end, src_ptr119[0..dest_end :1]); + vl(*const [1:1]u8, @as(*const [2]u8, src_ptr119), 0, 1, src_ptr119[0..][0..1 :1]); + vl([:1]const u8, @as(*const [2]u8, src_ptr119), 0, dest_len, src_ptr119[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as(*const [2]u8, src_ptr119), 1, 1, src_ptr119[1..1 :1]); + ve([:1]const u8, @as(*const [2]u8, src_ptr119), 1, dest_end, src_ptr119[1..dest_end :1]); + const src_mem25: [2]u8 = .{ 1, 0 }; + const src_ptr120: *const [1:0]u8 = src_mem25[0..1 :0]; + vs(*const [1:0]u8, @as(*const [1:0]u8, src_ptr120), 0, src_ptr120[0..]); + ve(*const [2]u8, @as(*const [1:0]u8, src_ptr120), 0, 2, src_ptr120[0..2]); + ve(*const [1:0]u8, @as(*const [1:0]u8, src_ptr120), 0, 1, src_ptr120[0..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr120), 0, dest_end, src_ptr120[0..dest_end]); + vl(*const [2]u8, @as(*const [1:0]u8, src_ptr120), 0, 2, src_ptr120[0..][0..2]); + vl(*const [1:0]u8, @as(*const [1:0]u8, src_ptr120), 0, 1, src_ptr120[0..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr120), 0, dest_len, src_ptr120[0..][0..dest_len]); + vs(*const [0:0]u8, @as(*const [1:0]u8, src_ptr120), 1, src_ptr120[1..]); + ve(*const [1]u8, @as(*const [1:0]u8, src_ptr120), 1, 2, src_ptr120[1..2]); + ve(*const [0:0]u8, @as(*const [1:0]u8, src_ptr120), 1, 1, src_ptr120[1..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr120), 1, dest_end, src_ptr120[1..dest_end]); + vl(*const [1]u8, @as(*const [1:0]u8, src_ptr120), 1, 1, src_ptr120[1..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr120), 1, dest_len, src_ptr120[1..][0..dest_len]); + const src_mem26: [3]u8 = .{ 1, 1, 1 }; + const src_ptr121: *const [3]u8 = src_mem26[0..3]; + vs(*const [3]u8, @as(*const [3]u8, src_ptr121), 0, src_ptr121[0..]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr121), 0, 2, src_ptr121[0..2]); + ve(*const [3]u8, @as(*const [3]u8, src_ptr121), 0, 3, src_ptr121[0..3]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr121), 0, 1, src_ptr121[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr121), 0, dest_end, src_ptr121[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr121), 0, dest_end, src_ptr121[0..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr121), 0, 2, src_ptr121[0..][0..2]); + vl(*const [3]u8, @as(*const [3]u8, src_ptr121), 0, 3, src_ptr121[0..][0..3]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr121), 0, 1, src_ptr121[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [3]u8, src_ptr121), 0, dest_len, src_ptr121[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [3]u8, src_ptr121), 0, dest_len, src_ptr121[0..][0..dest_len]); + vs(*const [2]u8, @as(*const [3]u8, src_ptr121), 1, src_ptr121[1..]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr121), 1, 2, src_ptr121[1..2]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr121), 1, 3, src_ptr121[1..3]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr121), 1, 1, src_ptr121[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr121), 1, dest_end, src_ptr121[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr121), 1, dest_end, src_ptr121[1..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr121), 1, 2, src_ptr121[1..][0..2]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr121), 1, 1, src_ptr121[1..][0..1]); + vl([]const u8, @as(*const [3]u8, src_ptr121), 1, dest_len, src_ptr121[1..][0..dest_len]); + vs(*const [0]u8, @as(*const [3]u8, src_ptr121), 3, src_ptr121[3..]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr121), 3, 3, src_ptr121[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr121), 3, dest_end, src_ptr121[3..dest_end]); + ve(*const [2:1]u8, @as(*const [3]u8, src_ptr121), 0, 2, src_ptr121[0..2 :1]); + ve(*const [1:1]u8, @as(*const [3]u8, src_ptr121), 0, 1, src_ptr121[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as(*const [3]u8, src_ptr121), 0, dest_end, src_ptr121[0..dest_end :1]); + vl(*const [2:1]u8, @as(*const [3]u8, src_ptr121), 0, 2, src_ptr121[0..][0..2 :1]); + vl(*const [1:1]u8, @as(*const [3]u8, src_ptr121), 0, 1, src_ptr121[0..][0..1 :1]); + vl([:1]const u8, @as(*const [3]u8, src_ptr121), 0, dest_len, src_ptr121[0..][0..dest_len :1]); + ve(*const [1:1]u8, @as(*const [3]u8, src_ptr121), 1, 2, src_ptr121[1..2 :1]); + ve(*const [0:1]u8, @as(*const [3]u8, src_ptr121), 1, 1, src_ptr121[1..1 :1]); + ve([:1]const u8, @as(*const [3]u8, src_ptr121), 1, dest_end, src_ptr121[1..dest_end :1]); + vl(*const [1:1]u8, @as(*const [3]u8, src_ptr121), 1, 1, src_ptr121[1..][0..1 :1]); + vl([:1]const u8, @as(*const [3]u8, src_ptr121), 1, dest_len, src_ptr121[1..][0..dest_len :1]); + const src_mem27: [3]u8 = .{ 1, 1, 0 }; + const src_ptr122: *const [2:0]u8 = src_mem27[0..2 :0]; + vs(*const [2:0]u8, @as(*const [2:0]u8, src_ptr122), 0, src_ptr122[0..]); + ve(*const [2:0]u8, @as(*const [2:0]u8, src_ptr122), 0, 2, src_ptr122[0..2]); + ve(*const [3]u8, @as(*const [2:0]u8, src_ptr122), 0, 3, src_ptr122[0..3]); + ve(*const [1]u8, @as(*const [2:0]u8, src_ptr122), 0, 1, src_ptr122[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_end, src_ptr122[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_end, src_ptr122[0..dest_end]); + vl(*const [2:0]u8, @as(*const [2:0]u8, src_ptr122), 0, 2, src_ptr122[0..][0..2]); + vl(*const [3]u8, @as(*const [2:0]u8, src_ptr122), 0, 3, src_ptr122[0..][0..3]); + vl(*const [1]u8, @as(*const [2:0]u8, src_ptr122), 0, 1, src_ptr122[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_len, src_ptr122[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_len, src_ptr122[0..][0..dest_len]); + vs(*const [1:0]u8, @as(*const [2:0]u8, src_ptr122), 1, src_ptr122[1..]); + ve(*const [1:0]u8, @as(*const [2:0]u8, src_ptr122), 1, 2, src_ptr122[1..2]); + ve(*const [2]u8, @as(*const [2:0]u8, src_ptr122), 1, 3, src_ptr122[1..3]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr122), 1, 1, src_ptr122[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr122), 1, dest_end, src_ptr122[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr122), 1, dest_end, src_ptr122[1..dest_end]); + vl(*const [2]u8, @as(*const [2:0]u8, src_ptr122), 1, 2, src_ptr122[1..][0..2]); + vl(*const [1:0]u8, @as(*const [2:0]u8, src_ptr122), 1, 1, src_ptr122[1..][0..1]); + vl([]const u8, @as(*const [2:0]u8, src_ptr122), 1, dest_len, src_ptr122[1..][0..dest_len]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr122), 3, 3, src_ptr122[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr122), 3, dest_end, src_ptr122[3..dest_end]); + ve(*const [1:1]u8, @as(*const [2:0]u8, src_ptr122), 0, 1, src_ptr122[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_end, src_ptr122[0..dest_end :1]); + vl(*const [1:1]u8, @as(*const [2:0]u8, src_ptr122), 0, 1, src_ptr122[0..][0..1 :1]); + vl([:1]const u8, @as(*const [2:0]u8, src_ptr122), 0, dest_len, src_ptr122[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as(*const [2:0]u8, src_ptr122), 1, 1, src_ptr122[1..1 :1]); + ve([:1]const u8, @as(*const [2:0]u8, src_ptr122), 1, dest_end, src_ptr122[1..dest_end :1]); + const src_mem28: [1]u8 = .{1}; + const src_ptr123: *const [1]u8 = src_mem28[0..1]; + vs(*const [1]u8, @as(*const [1]u8, src_ptr123), 0, src_ptr123[0..]); + ve(*const [1]u8, @as(*const [1]u8, src_ptr123), 0, 1, src_ptr123[0..1]); + ve([]const u8, @as(*const [1]u8, src_ptr123), 0, dest_end, src_ptr123[0..dest_end]); + vl(*const [1]u8, @as(*const [1]u8, src_ptr123), 0, 1, src_ptr123[0..][0..1]); + vl([]const u8, @as(*const [1]u8, src_ptr123), 0, dest_len, src_ptr123[0..][0..dest_len]); + vs(*const [0]u8, @as(*const [1]u8, src_ptr123), 1, src_ptr123[1..]); + ve(*const [0]u8, @as(*const [1]u8, src_ptr123), 1, 1, src_ptr123[1..1]); + ve([]const u8, @as(*const [1]u8, src_ptr123), 1, dest_end, src_ptr123[1..dest_end]); + const src_mem29: [1]u8 = .{0}; + const src_ptr124: *const [0:0]u8 = src_mem29[0..0 :0]; + vs(*const [0:0]u8, @as(*const [0:0]u8, src_ptr124), 0, src_ptr124[0..]); + ve(*const [1]u8, @as(*const [0:0]u8, src_ptr124), 0, 1, src_ptr124[0..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr124), 0, dest_end, src_ptr124[0..dest_end]); + vl(*const [1]u8, @as(*const [0:0]u8, src_ptr124), 0, 1, src_ptr124[0..][0..1]); + vl([]const u8, @as(*const [0:0]u8, src_ptr124), 0, dest_len, src_ptr124[0..][0..dest_len]); + ve(*const [0]u8, @as(*const [0:0]u8, src_ptr124), 1, 1, src_ptr124[1..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr124), 1, dest_end, src_ptr124[1..dest_end]); + var src_ptr125: *const [2]u8 = src_mem24[0..2]; + vs(*const [2]u8, @as(*const [2]u8, src_ptr125), 0, src_ptr125[0..]); + ve(*const [2]u8, @as(*const [2]u8, src_ptr125), 0, 2, src_ptr125[0..2]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr125), 0, 1, src_ptr125[0..1]); + ve([]const u8, @as(*const [2]u8, src_ptr125), 0, dest_end, src_ptr125[0..dest_end]); + vl(*const [2]u8, @as(*const [2]u8, src_ptr125), 0, 2, src_ptr125[0..][0..2]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr125), 0, 1, src_ptr125[0..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr125), 0, dest_len, src_ptr125[0..][0..dest_len]); + vs(*const [1]u8, @as(*const [2]u8, src_ptr125), 1, src_ptr125[1..]); + ve(*const [1]u8, @as(*const [2]u8, src_ptr125), 1, 2, src_ptr125[1..2]); + ve(*const [0]u8, @as(*const [2]u8, src_ptr125), 1, 1, src_ptr125[1..1]); + ve([]const u8, @as(*const [2]u8, src_ptr125), 1, dest_end, src_ptr125[1..dest_end]); + vl(*const [1]u8, @as(*const [2]u8, src_ptr125), 1, 1, src_ptr125[1..][0..1]); + vl([]const u8, @as(*const [2]u8, src_ptr125), 1, dest_len, src_ptr125[1..][0..dest_len]); + ve(*const [1:1]u8, @as(*const [2]u8, src_ptr125), 0, 1, src_ptr125[0..1 :1]); + ve([:1]const u8, @as(*const [2]u8, src_ptr125), 0, dest_end, src_ptr125[0..dest_end :1]); + vl(*const [1:1]u8, @as(*const [2]u8, src_ptr125), 0, 1, src_ptr125[0..][0..1 :1]); + vl([:1]const u8, @as(*const [2]u8, src_ptr125), 0, dest_len, src_ptr125[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as(*const [2]u8, src_ptr125), 1, 1, src_ptr125[1..1 :1]); + ve([:1]const u8, @as(*const [2]u8, src_ptr125), 1, dest_end, src_ptr125[1..dest_end :1]); + var src_ptr126: *const [1:0]u8 = src_mem25[0..1 :0]; + vs(*const [1:0]u8, @as(*const [1:0]u8, src_ptr126), 0, src_ptr126[0..]); + ve(*const [2]u8, @as(*const [1:0]u8, src_ptr126), 0, 2, src_ptr126[0..2]); + ve(*const [1:0]u8, @as(*const [1:0]u8, src_ptr126), 0, 1, src_ptr126[0..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr126), 0, dest_end, src_ptr126[0..dest_end]); + vl(*const [2]u8, @as(*const [1:0]u8, src_ptr126), 0, 2, src_ptr126[0..][0..2]); + vl(*const [1:0]u8, @as(*const [1:0]u8, src_ptr126), 0, 1, src_ptr126[0..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr126), 0, dest_len, src_ptr126[0..][0..dest_len]); + vs(*const [0:0]u8, @as(*const [1:0]u8, src_ptr126), 1, src_ptr126[1..]); + ve(*const [1]u8, @as(*const [1:0]u8, src_ptr126), 1, 2, src_ptr126[1..2]); + ve(*const [0:0]u8, @as(*const [1:0]u8, src_ptr126), 1, 1, src_ptr126[1..1]); + ve([]const u8, @as(*const [1:0]u8, src_ptr126), 1, dest_end, src_ptr126[1..dest_end]); + vl(*const [1]u8, @as(*const [1:0]u8, src_ptr126), 1, 1, src_ptr126[1..][0..1]); + vl([]const u8, @as(*const [1:0]u8, src_ptr126), 1, dest_len, src_ptr126[1..][0..dest_len]); + var src_ptr127: *const [3]u8 = src_mem26[0..3]; + vs(*const [3]u8, @as(*const [3]u8, src_ptr127), 0, src_ptr127[0..]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr127), 0, 2, src_ptr127[0..2]); + ve(*const [3]u8, @as(*const [3]u8, src_ptr127), 0, 3, src_ptr127[0..3]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr127), 0, 1, src_ptr127[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr127), 0, dest_end, src_ptr127[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr127), 0, dest_end, src_ptr127[0..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr127), 0, 2, src_ptr127[0..][0..2]); + vl(*const [3]u8, @as(*const [3]u8, src_ptr127), 0, 3, src_ptr127[0..][0..3]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr127), 0, 1, src_ptr127[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [3]u8, src_ptr127), 0, dest_len, src_ptr127[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [3]u8, src_ptr127), 0, dest_len, src_ptr127[0..][0..dest_len]); + vs(*const [2]u8, @as(*const [3]u8, src_ptr127), 1, src_ptr127[1..]); + ve(*const [1]u8, @as(*const [3]u8, src_ptr127), 1, 2, src_ptr127[1..2]); + ve(*const [2]u8, @as(*const [3]u8, src_ptr127), 1, 3, src_ptr127[1..3]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr127), 1, 1, src_ptr127[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr127), 1, dest_end, src_ptr127[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [3]u8, src_ptr127), 1, dest_end, src_ptr127[1..dest_end]); + vl(*const [2]u8, @as(*const [3]u8, src_ptr127), 1, 2, src_ptr127[1..][0..2]); + vl(*const [1]u8, @as(*const [3]u8, src_ptr127), 1, 1, src_ptr127[1..][0..1]); + vl([]const u8, @as(*const [3]u8, src_ptr127), 1, dest_len, src_ptr127[1..][0..dest_len]); + vs(*const [0]u8, @as(*const [3]u8, src_ptr127), 3, src_ptr127[3..]); + ve(*const [0]u8, @as(*const [3]u8, src_ptr127), 3, 3, src_ptr127[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [3]u8, src_ptr127), 3, dest_end, src_ptr127[3..dest_end]); + ve(*const [2:1]u8, @as(*const [3]u8, src_ptr127), 0, 2, src_ptr127[0..2 :1]); + ve(*const [1:1]u8, @as(*const [3]u8, src_ptr127), 0, 1, src_ptr127[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as(*const [3]u8, src_ptr127), 0, dest_end, src_ptr127[0..dest_end :1]); + vl(*const [2:1]u8, @as(*const [3]u8, src_ptr127), 0, 2, src_ptr127[0..][0..2 :1]); + vl(*const [1:1]u8, @as(*const [3]u8, src_ptr127), 0, 1, src_ptr127[0..][0..1 :1]); + vl([:1]const u8, @as(*const [3]u8, src_ptr127), 0, dest_len, src_ptr127[0..][0..dest_len :1]); + ve(*const [1:1]u8, @as(*const [3]u8, src_ptr127), 1, 2, src_ptr127[1..2 :1]); + ve(*const [0:1]u8, @as(*const [3]u8, src_ptr127), 1, 1, src_ptr127[1..1 :1]); + ve([:1]const u8, @as(*const [3]u8, src_ptr127), 1, dest_end, src_ptr127[1..dest_end :1]); + vl(*const [1:1]u8, @as(*const [3]u8, src_ptr127), 1, 1, src_ptr127[1..][0..1 :1]); + vl([:1]const u8, @as(*const [3]u8, src_ptr127), 1, dest_len, src_ptr127[1..][0..dest_len :1]); + var src_ptr128: *const [2:0]u8 = src_mem27[0..2 :0]; + vs(*const [2:0]u8, @as(*const [2:0]u8, src_ptr128), 0, src_ptr128[0..]); + ve(*const [2:0]u8, @as(*const [2:0]u8, src_ptr128), 0, 2, src_ptr128[0..2]); + ve(*const [3]u8, @as(*const [2:0]u8, src_ptr128), 0, 3, src_ptr128[0..3]); + ve(*const [1]u8, @as(*const [2:0]u8, src_ptr128), 0, 1, src_ptr128[0..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_end, src_ptr128[0..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_end, src_ptr128[0..dest_end]); + vl(*const [2:0]u8, @as(*const [2:0]u8, src_ptr128), 0, 2, src_ptr128[0..][0..2]); + vl(*const [3]u8, @as(*const [2:0]u8, src_ptr128), 0, 3, src_ptr128[0..][0..3]); + vl(*const [1]u8, @as(*const [2:0]u8, src_ptr128), 0, 1, src_ptr128[0..][0..1]); + dest_len = 3; + vl([]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_len, src_ptr128[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_len, src_ptr128[0..][0..dest_len]); + vs(*const [1:0]u8, @as(*const [2:0]u8, src_ptr128), 1, src_ptr128[1..]); + ve(*const [1:0]u8, @as(*const [2:0]u8, src_ptr128), 1, 2, src_ptr128[1..2]); + ve(*const [2]u8, @as(*const [2:0]u8, src_ptr128), 1, 3, src_ptr128[1..3]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr128), 1, 1, src_ptr128[1..1]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr128), 1, dest_end, src_ptr128[1..dest_end]); + dest_end = 1; + ve([]const u8, @as(*const [2:0]u8, src_ptr128), 1, dest_end, src_ptr128[1..dest_end]); + vl(*const [2]u8, @as(*const [2:0]u8, src_ptr128), 1, 2, src_ptr128[1..][0..2]); + vl(*const [1:0]u8, @as(*const [2:0]u8, src_ptr128), 1, 1, src_ptr128[1..][0..1]); + vl([]const u8, @as(*const [2:0]u8, src_ptr128), 1, dest_len, src_ptr128[1..][0..dest_len]); + ve(*const [0]u8, @as(*const [2:0]u8, src_ptr128), 3, 3, src_ptr128[3..3]); + dest_end = 3; + ve([]const u8, @as(*const [2:0]u8, src_ptr128), 3, dest_end, src_ptr128[3..dest_end]); + ve(*const [1:1]u8, @as(*const [2:0]u8, src_ptr128), 0, 1, src_ptr128[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_end, src_ptr128[0..dest_end :1]); + vl(*const [1:1]u8, @as(*const [2:0]u8, src_ptr128), 0, 1, src_ptr128[0..][0..1 :1]); + vl([:1]const u8, @as(*const [2:0]u8, src_ptr128), 0, dest_len, src_ptr128[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as(*const [2:0]u8, src_ptr128), 1, 1, src_ptr128[1..1 :1]); + ve([:1]const u8, @as(*const [2:0]u8, src_ptr128), 1, dest_end, src_ptr128[1..dest_end :1]); + var src_ptr129: *const [1]u8 = src_mem28[0..1]; + vs(*const [1]u8, @as(*const [1]u8, src_ptr129), 0, src_ptr129[0..]); + ve(*const [1]u8, @as(*const [1]u8, src_ptr129), 0, 1, src_ptr129[0..1]); + ve([]const u8, @as(*const [1]u8, src_ptr129), 0, dest_end, src_ptr129[0..dest_end]); + vl(*const [1]u8, @as(*const [1]u8, src_ptr129), 0, 1, src_ptr129[0..][0..1]); + vl([]const u8, @as(*const [1]u8, src_ptr129), 0, dest_len, src_ptr129[0..][0..dest_len]); + vs(*const [0]u8, @as(*const [1]u8, src_ptr129), 1, src_ptr129[1..]); + ve(*const [0]u8, @as(*const [1]u8, src_ptr129), 1, 1, src_ptr129[1..1]); + ve([]const u8, @as(*const [1]u8, src_ptr129), 1, dest_end, src_ptr129[1..dest_end]); + var src_ptr130: *const [0:0]u8 = src_mem29[0..0 :0]; + vs(*const [0:0]u8, @as(*const [0:0]u8, src_ptr130), 0, src_ptr130[0..]); + ve(*const [1]u8, @as(*const [0:0]u8, src_ptr130), 0, 1, src_ptr130[0..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr130), 0, dest_end, src_ptr130[0..dest_end]); + vl(*const [1]u8, @as(*const [0:0]u8, src_ptr130), 0, 1, src_ptr130[0..][0..1]); + vl([]const u8, @as(*const [0:0]u8, src_ptr130), 0, dest_len, src_ptr130[0..][0..dest_len]); + ve(*const [0]u8, @as(*const [0:0]u8, src_ptr130), 1, 1, src_ptr130[1..1]); + ve([]const u8, @as(*const [0:0]u8, src_ptr130), 1, dest_end, src_ptr130[1..dest_end]); + const src_ptr131: []const u8 = src_mem24[0..2]; + vs(*const [2]u8, @as([]const u8, src_ptr131), 0, src_ptr131[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr131), 0, 2, src_ptr131[0..2]); + ve(*const [1]u8, @as([]const u8, src_ptr131), 0, 1, src_ptr131[0..1]); + ve([]const u8, @as([]const u8, src_ptr131), 0, dest_end, src_ptr131[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr131), 0, 2, src_ptr131[0..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr131), 0, 1, src_ptr131[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr131), 0, dest_len, src_ptr131[0..][0..dest_len]); + vs(*const [1]u8, @as([]const u8, src_ptr131), 1, src_ptr131[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr131), 1, 2, src_ptr131[1..2]); + ve(*const [0]u8, @as([]const u8, src_ptr131), 1, 1, src_ptr131[1..1]); + ve([]const u8, @as([]const u8, src_ptr131), 1, dest_end, src_ptr131[1..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr131), 1, 1, src_ptr131[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr131), 1, dest_len, src_ptr131[1..][0..dest_len]); + ve(*const [1:1]u8, @as([]const u8, src_ptr131), 0, 1, src_ptr131[0..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr131), 0, dest_end, src_ptr131[0..dest_end :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr131), 0, 1, src_ptr131[0..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr131), 0, dest_len, src_ptr131[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as([]const u8, src_ptr131), 1, 1, src_ptr131[1..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr131), 1, dest_end, src_ptr131[1..dest_end :1]); + const src_ptr132: [:0]const u8 = src_mem25[0..1 :0]; + vs(*const [1:0]u8, @as([:0]const u8, src_ptr132), 0, src_ptr132[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr132), 0, 2, src_ptr132[0..2]); + ve(*const [1:0]u8, @as([:0]const u8, src_ptr132), 0, 1, src_ptr132[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr132), 0, dest_end, src_ptr132[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr132), 0, 2, src_ptr132[0..][0..2]); + vl(*const [1:0]u8, @as([:0]const u8, src_ptr132), 0, 1, src_ptr132[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr132), 0, dest_len, src_ptr132[0..][0..dest_len]); + vs(*const [0:0]u8, @as([:0]const u8, src_ptr132), 1, src_ptr132[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr132), 1, 2, src_ptr132[1..2]); + ve(*const [0:0]u8, @as([:0]const u8, src_ptr132), 1, 1, src_ptr132[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr132), 1, dest_end, src_ptr132[1..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr132), 1, 1, src_ptr132[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr132), 1, dest_len, src_ptr132[1..][0..dest_len]); + const src_ptr133: []const u8 = src_mem26[0..3]; + vs(*const [3]u8, @as([]const u8, src_ptr133), 0, src_ptr133[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr133), 0, 2, src_ptr133[0..2]); + ve(*const [3]u8, @as([]const u8, src_ptr133), 0, 3, src_ptr133[0..3]); + ve(*const [1]u8, @as([]const u8, src_ptr133), 0, 1, src_ptr133[0..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr133), 0, dest_end, src_ptr133[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr133), 0, dest_end, src_ptr133[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr133), 0, 2, src_ptr133[0..][0..2]); + vl(*const [3]u8, @as([]const u8, src_ptr133), 0, 3, src_ptr133[0..][0..3]); + vl(*const [1]u8, @as([]const u8, src_ptr133), 0, 1, src_ptr133[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([]const u8, src_ptr133), 0, dest_len, src_ptr133[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([]const u8, src_ptr133), 0, dest_len, src_ptr133[0..][0..dest_len]); + vs(*const [2]u8, @as([]const u8, src_ptr133), 1, src_ptr133[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr133), 1, 2, src_ptr133[1..2]); + ve(*const [2]u8, @as([]const u8, src_ptr133), 1, 3, src_ptr133[1..3]); + ve(*const [0]u8, @as([]const u8, src_ptr133), 1, 1, src_ptr133[1..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr133), 1, dest_end, src_ptr133[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr133), 1, dest_end, src_ptr133[1..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr133), 1, 2, src_ptr133[1..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr133), 1, 1, src_ptr133[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr133), 1, dest_len, src_ptr133[1..][0..dest_len]); + vs(*const [0]u8, @as([]const u8, src_ptr133), 3, src_ptr133[3..]); + ve(*const [0]u8, @as([]const u8, src_ptr133), 3, 3, src_ptr133[3..3]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr133), 3, dest_end, src_ptr133[3..dest_end]); + ve(*const [2:1]u8, @as([]const u8, src_ptr133), 0, 2, src_ptr133[0..2 :1]); + ve(*const [1:1]u8, @as([]const u8, src_ptr133), 0, 1, src_ptr133[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([]const u8, src_ptr133), 0, dest_end, src_ptr133[0..dest_end :1]); + vl(*const [2:1]u8, @as([]const u8, src_ptr133), 0, 2, src_ptr133[0..][0..2 :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr133), 0, 1, src_ptr133[0..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr133), 0, dest_len, src_ptr133[0..][0..dest_len :1]); + ve(*const [1:1]u8, @as([]const u8, src_ptr133), 1, 2, src_ptr133[1..2 :1]); + ve(*const [0:1]u8, @as([]const u8, src_ptr133), 1, 1, src_ptr133[1..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr133), 1, dest_end, src_ptr133[1..dest_end :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr133), 1, 1, src_ptr133[1..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr133), 1, dest_len, src_ptr133[1..][0..dest_len :1]); + const src_ptr134: [:0]const u8 = src_mem27[0..2 :0]; + vs(*const [2:0]u8, @as([:0]const u8, src_ptr134), 0, src_ptr134[0..]); + ve(*const [2:0]u8, @as([:0]const u8, src_ptr134), 0, 2, src_ptr134[0..2]); + ve(*const [3]u8, @as([:0]const u8, src_ptr134), 0, 3, src_ptr134[0..3]); + ve(*const [1]u8, @as([:0]const u8, src_ptr134), 0, 1, src_ptr134[0..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr134), 0, dest_end, src_ptr134[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr134), 0, dest_end, src_ptr134[0..dest_end]); + vl(*const [2:0]u8, @as([:0]const u8, src_ptr134), 0, 2, src_ptr134[0..][0..2]); + vl(*const [3]u8, @as([:0]const u8, src_ptr134), 0, 3, src_ptr134[0..][0..3]); + vl(*const [1]u8, @as([:0]const u8, src_ptr134), 0, 1, src_ptr134[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([:0]const u8, src_ptr134), 0, dest_len, src_ptr134[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([:0]const u8, src_ptr134), 0, dest_len, src_ptr134[0..][0..dest_len]); + vs(*const [1:0]u8, @as([:0]const u8, src_ptr134), 1, src_ptr134[1..]); + ve(*const [1:0]u8, @as([:0]const u8, src_ptr134), 1, 2, src_ptr134[1..2]); + ve(*const [2]u8, @as([:0]const u8, src_ptr134), 1, 3, src_ptr134[1..3]); + ve(*const [0]u8, @as([:0]const u8, src_ptr134), 1, 1, src_ptr134[1..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr134), 1, dest_end, src_ptr134[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr134), 1, dest_end, src_ptr134[1..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr134), 1, 2, src_ptr134[1..][0..2]); + vl(*const [1:0]u8, @as([:0]const u8, src_ptr134), 1, 1, src_ptr134[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr134), 1, dest_len, src_ptr134[1..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr134), 3, 3, src_ptr134[3..3]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr134), 3, dest_end, src_ptr134[3..dest_end]); + ve(*const [1:1]u8, @as([:0]const u8, src_ptr134), 0, 1, src_ptr134[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([:0]const u8, src_ptr134), 0, dest_end, src_ptr134[0..dest_end :1]); + vl(*const [1:1]u8, @as([:0]const u8, src_ptr134), 0, 1, src_ptr134[0..][0..1 :1]); + vl([:1]const u8, @as([:0]const u8, src_ptr134), 0, dest_len, src_ptr134[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as([:0]const u8, src_ptr134), 1, 1, src_ptr134[1..1 :1]); + ve([:1]const u8, @as([:0]const u8, src_ptr134), 1, dest_end, src_ptr134[1..dest_end :1]); + const src_ptr135: []const u8 = src_mem28[0..1]; + vs(*const [1]u8, @as([]const u8, src_ptr135), 0, src_ptr135[0..]); + ve(*const [1]u8, @as([]const u8, src_ptr135), 0, 1, src_ptr135[0..1]); + ve([]const u8, @as([]const u8, src_ptr135), 0, dest_end, src_ptr135[0..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr135), 0, 1, src_ptr135[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr135), 0, dest_len, src_ptr135[0..][0..dest_len]); + vs(*const [0]u8, @as([]const u8, src_ptr135), 1, src_ptr135[1..]); + ve(*const [0]u8, @as([]const u8, src_ptr135), 1, 1, src_ptr135[1..1]); + ve([]const u8, @as([]const u8, src_ptr135), 1, dest_end, src_ptr135[1..dest_end]); + const src_ptr136: [:0]const u8 = src_mem29[0..0 :0]; + vs(*const [0:0]u8, @as([:0]const u8, src_ptr136), 0, src_ptr136[0..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr136), 0, 1, src_ptr136[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr136), 0, dest_end, src_ptr136[0..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr136), 0, 1, src_ptr136[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr136), 0, dest_len, src_ptr136[0..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr136), 1, 1, src_ptr136[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr136), 1, dest_end, src_ptr136[1..dest_end]); + var src_ptr137: []const u8 = src_mem24[0..2]; + vs([]const u8, @as([]const u8, src_ptr137), 0, src_ptr137[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr137), 0, 2, src_ptr137[0..2]); + ve(*const [1]u8, @as([]const u8, src_ptr137), 0, 1, src_ptr137[0..1]); + ve([]const u8, @as([]const u8, src_ptr137), 0, dest_end, src_ptr137[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr137), 0, 2, src_ptr137[0..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr137), 0, 1, src_ptr137[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr137), 0, dest_len, src_ptr137[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr137), 1, src_ptr137[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr137), 1, 2, src_ptr137[1..2]); + ve(*const [0]u8, @as([]const u8, src_ptr137), 1, 1, src_ptr137[1..1]); + ve([]const u8, @as([]const u8, src_ptr137), 1, dest_end, src_ptr137[1..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr137), 1, 1, src_ptr137[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr137), 1, dest_len, src_ptr137[1..][0..dest_len]); + ve(*const [1:1]u8, @as([]const u8, src_ptr137), 0, 1, src_ptr137[0..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr137), 0, dest_end, src_ptr137[0..dest_end :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr137), 0, 1, src_ptr137[0..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr137), 0, dest_len, src_ptr137[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as([]const u8, src_ptr137), 1, 1, src_ptr137[1..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr137), 1, dest_end, src_ptr137[1..dest_end :1]); + var src_ptr138: [:0]const u8 = src_mem25[0..1 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr138), 0, src_ptr138[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr138), 0, 2, src_ptr138[0..2]); + ve(*const [1]u8, @as([:0]const u8, src_ptr138), 0, 1, src_ptr138[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr138), 0, dest_end, src_ptr138[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr138), 0, 2, src_ptr138[0..][0..2]); + vl(*const [1]u8, @as([:0]const u8, src_ptr138), 0, 1, src_ptr138[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr138), 0, dest_len, src_ptr138[0..][0..dest_len]); + vs([:0]const u8, @as([:0]const u8, src_ptr138), 1, src_ptr138[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr138), 1, 2, src_ptr138[1..2]); + ve(*const [0]u8, @as([:0]const u8, src_ptr138), 1, 1, src_ptr138[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr138), 1, dest_end, src_ptr138[1..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr138), 1, 1, src_ptr138[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr138), 1, dest_len, src_ptr138[1..][0..dest_len]); + var src_ptr139: []const u8 = src_mem26[0..3]; + vs([]const u8, @as([]const u8, src_ptr139), 0, src_ptr139[0..]); + ve(*const [2]u8, @as([]const u8, src_ptr139), 0, 2, src_ptr139[0..2]); + ve(*const [3]u8, @as([]const u8, src_ptr139), 0, 3, src_ptr139[0..3]); + ve(*const [1]u8, @as([]const u8, src_ptr139), 0, 1, src_ptr139[0..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr139), 0, dest_end, src_ptr139[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr139), 0, dest_end, src_ptr139[0..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr139), 0, 2, src_ptr139[0..][0..2]); + vl(*const [3]u8, @as([]const u8, src_ptr139), 0, 3, src_ptr139[0..][0..3]); + vl(*const [1]u8, @as([]const u8, src_ptr139), 0, 1, src_ptr139[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([]const u8, src_ptr139), 0, dest_len, src_ptr139[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([]const u8, src_ptr139), 0, dest_len, src_ptr139[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr139), 1, src_ptr139[1..]); + ve(*const [1]u8, @as([]const u8, src_ptr139), 1, 2, src_ptr139[1..2]); + ve(*const [2]u8, @as([]const u8, src_ptr139), 1, 3, src_ptr139[1..3]); + ve(*const [0]u8, @as([]const u8, src_ptr139), 1, 1, src_ptr139[1..1]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr139), 1, dest_end, src_ptr139[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([]const u8, src_ptr139), 1, dest_end, src_ptr139[1..dest_end]); + vl(*const [2]u8, @as([]const u8, src_ptr139), 1, 2, src_ptr139[1..][0..2]); + vl(*const [1]u8, @as([]const u8, src_ptr139), 1, 1, src_ptr139[1..][0..1]); + vl([]const u8, @as([]const u8, src_ptr139), 1, dest_len, src_ptr139[1..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr139), 3, src_ptr139[3..]); + ve(*const [0]u8, @as([]const u8, src_ptr139), 3, 3, src_ptr139[3..3]); + dest_end = 3; + ve([]const u8, @as([]const u8, src_ptr139), 3, dest_end, src_ptr139[3..dest_end]); + ve(*const [2:1]u8, @as([]const u8, src_ptr139), 0, 2, src_ptr139[0..2 :1]); + ve(*const [1:1]u8, @as([]const u8, src_ptr139), 0, 1, src_ptr139[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([]const u8, src_ptr139), 0, dest_end, src_ptr139[0..dest_end :1]); + vl(*const [2:1]u8, @as([]const u8, src_ptr139), 0, 2, src_ptr139[0..][0..2 :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr139), 0, 1, src_ptr139[0..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr139), 0, dest_len, src_ptr139[0..][0..dest_len :1]); + ve(*const [1:1]u8, @as([]const u8, src_ptr139), 1, 2, src_ptr139[1..2 :1]); + ve(*const [0:1]u8, @as([]const u8, src_ptr139), 1, 1, src_ptr139[1..1 :1]); + ve([:1]const u8, @as([]const u8, src_ptr139), 1, dest_end, src_ptr139[1..dest_end :1]); + vl(*const [1:1]u8, @as([]const u8, src_ptr139), 1, 1, src_ptr139[1..][0..1 :1]); + vl([:1]const u8, @as([]const u8, src_ptr139), 1, dest_len, src_ptr139[1..][0..dest_len :1]); + var src_ptr140: [:0]const u8 = src_mem27[0..2 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr140), 0, src_ptr140[0..]); + ve(*const [2]u8, @as([:0]const u8, src_ptr140), 0, 2, src_ptr140[0..2]); + ve(*const [3]u8, @as([:0]const u8, src_ptr140), 0, 3, src_ptr140[0..3]); + ve(*const [1]u8, @as([:0]const u8, src_ptr140), 0, 1, src_ptr140[0..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr140), 0, dest_end, src_ptr140[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr140), 0, dest_end, src_ptr140[0..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr140), 0, 2, src_ptr140[0..][0..2]); + vl(*const [3]u8, @as([:0]const u8, src_ptr140), 0, 3, src_ptr140[0..][0..3]); + vl(*const [1]u8, @as([:0]const u8, src_ptr140), 0, 1, src_ptr140[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([:0]const u8, src_ptr140), 0, dest_len, src_ptr140[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([:0]const u8, src_ptr140), 0, dest_len, src_ptr140[0..][0..dest_len]); + vs([:0]const u8, @as([:0]const u8, src_ptr140), 1, src_ptr140[1..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr140), 1, 2, src_ptr140[1..2]); + ve(*const [2]u8, @as([:0]const u8, src_ptr140), 1, 3, src_ptr140[1..3]); + ve(*const [0]u8, @as([:0]const u8, src_ptr140), 1, 1, src_ptr140[1..1]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr140), 1, dest_end, src_ptr140[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([:0]const u8, src_ptr140), 1, dest_end, src_ptr140[1..dest_end]); + vl(*const [2]u8, @as([:0]const u8, src_ptr140), 1, 2, src_ptr140[1..][0..2]); + vl(*const [1]u8, @as([:0]const u8, src_ptr140), 1, 1, src_ptr140[1..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr140), 1, dest_len, src_ptr140[1..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr140), 3, 3, src_ptr140[3..3]); + dest_end = 3; + ve([]const u8, @as([:0]const u8, src_ptr140), 3, dest_end, src_ptr140[3..dest_end]); + ve(*const [1:1]u8, @as([:0]const u8, src_ptr140), 0, 1, src_ptr140[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([:0]const u8, src_ptr140), 0, dest_end, src_ptr140[0..dest_end :1]); + vl(*const [1:1]u8, @as([:0]const u8, src_ptr140), 0, 1, src_ptr140[0..][0..1 :1]); + vl([:1]const u8, @as([:0]const u8, src_ptr140), 0, dest_len, src_ptr140[0..][0..dest_len :1]); + ve(*const [0:1]u8, @as([:0]const u8, src_ptr140), 1, 1, src_ptr140[1..1 :1]); + ve([:1]const u8, @as([:0]const u8, src_ptr140), 1, dest_end, src_ptr140[1..dest_end :1]); + var src_ptr141: []const u8 = src_mem28[0..1]; + vs([]const u8, @as([]const u8, src_ptr141), 0, src_ptr141[0..]); + ve(*const [1]u8, @as([]const u8, src_ptr141), 0, 1, src_ptr141[0..1]); + ve([]const u8, @as([]const u8, src_ptr141), 0, dest_end, src_ptr141[0..dest_end]); + vl(*const [1]u8, @as([]const u8, src_ptr141), 0, 1, src_ptr141[0..][0..1]); + vl([]const u8, @as([]const u8, src_ptr141), 0, dest_len, src_ptr141[0..][0..dest_len]); + vs([]const u8, @as([]const u8, src_ptr141), 1, src_ptr141[1..]); + ve(*const [0]u8, @as([]const u8, src_ptr141), 1, 1, src_ptr141[1..1]); + ve([]const u8, @as([]const u8, src_ptr141), 1, dest_end, src_ptr141[1..dest_end]); + var src_ptr142: [:0]const u8 = src_mem29[0..0 :0]; + vs([:0]const u8, @as([:0]const u8, src_ptr142), 0, src_ptr142[0..]); + ve(*const [1]u8, @as([:0]const u8, src_ptr142), 0, 1, src_ptr142[0..1]); + ve([]const u8, @as([:0]const u8, src_ptr142), 0, dest_end, src_ptr142[0..dest_end]); + vl(*const [1]u8, @as([:0]const u8, src_ptr142), 0, 1, src_ptr142[0..][0..1]); + vl([]const u8, @as([:0]const u8, src_ptr142), 0, dest_len, src_ptr142[0..][0..dest_len]); + ve(*const [0]u8, @as([:0]const u8, src_ptr142), 1, 1, src_ptr142[1..1]); + ve([]const u8, @as([:0]const u8, src_ptr142), 1, dest_end, src_ptr142[1..dest_end]); + const src_ptr143: [*]const u8 = @ptrCast(&src_mem24); + vs([*]const u8, @as([*]const u8, src_ptr143), 0, src_ptr143[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr143), 0, 2, src_ptr143[0..2]); + ve(*const [1]u8, @as([*]const u8, src_ptr143), 0, 1, src_ptr143[0..1]); + ve([]const u8, @as([*]const u8, src_ptr143), 0, dest_end, src_ptr143[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr143), 0, 2, src_ptr143[0..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr143), 0, 1, src_ptr143[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr143), 0, dest_len, src_ptr143[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr143), 1, src_ptr143[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr143), 1, 2, src_ptr143[1..2]); + ve(*const [0]u8, @as([*]const u8, src_ptr143), 1, 1, src_ptr143[1..1]); + ve([]const u8, @as([*]const u8, src_ptr143), 1, dest_end, src_ptr143[1..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr143), 1, 1, src_ptr143[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr143), 1, dest_len, src_ptr143[1..][0..dest_len]); + vs([*:1]const u8, @as([*]const u8, src_ptr143), 0, src_ptr143[0.. :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr143), 0, 1, src_ptr143[0..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr143), 0, dest_end, src_ptr143[0..dest_end :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr143), 0, 1, src_ptr143[0..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr143), 0, dest_len, src_ptr143[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr143), 1, src_ptr143[1.. :1]); + ve(*const [0:1]u8, @as([*]const u8, src_ptr143), 1, 1, src_ptr143[1..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr143), 1, dest_end, src_ptr143[1..dest_end :1]); + const src_ptr144: [*:0]const u8 = @ptrCast(&src_mem25); + vs([*]const u8, @as([*:0]const u8, src_ptr144), 0, src_ptr144[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr144), 0, 2, src_ptr144[0..2]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr144), 0, 1, src_ptr144[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr144), 0, dest_end, src_ptr144[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr144), 0, 2, src_ptr144[0..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr144), 0, 1, src_ptr144[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr144), 0, dest_len, src_ptr144[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr144), 1, src_ptr144[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr144), 1, 2, src_ptr144[1..2]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr144), 1, 1, src_ptr144[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr144), 1, dest_end, src_ptr144[1..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr144), 1, 1, src_ptr144[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr144), 1, dest_len, src_ptr144[1..][0..dest_len]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr144), 0, src_ptr144[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr144), 1, src_ptr144[1.. :1]); + const src_ptr145: [*]const u8 = @ptrCast(&src_mem26); + vs([*]const u8, @as([*]const u8, src_ptr145), 0, src_ptr145[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr145), 0, 2, src_ptr145[0..2]); + ve(*const [3]u8, @as([*]const u8, src_ptr145), 0, 3, src_ptr145[0..3]); + ve(*const [1]u8, @as([*]const u8, src_ptr145), 0, 1, src_ptr145[0..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr145), 0, dest_end, src_ptr145[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr145), 0, dest_end, src_ptr145[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr145), 0, 2, src_ptr145[0..][0..2]); + vl(*const [3]u8, @as([*]const u8, src_ptr145), 0, 3, src_ptr145[0..][0..3]); + vl(*const [1]u8, @as([*]const u8, src_ptr145), 0, 1, src_ptr145[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*]const u8, src_ptr145), 0, dest_len, src_ptr145[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*]const u8, src_ptr145), 0, dest_len, src_ptr145[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr145), 1, src_ptr145[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr145), 1, 2, src_ptr145[1..2]); + ve(*const [2]u8, @as([*]const u8, src_ptr145), 1, 3, src_ptr145[1..3]); + ve(*const [0]u8, @as([*]const u8, src_ptr145), 1, 1, src_ptr145[1..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr145), 1, dest_end, src_ptr145[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr145), 1, dest_end, src_ptr145[1..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr145), 1, 2, src_ptr145[1..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr145), 1, 1, src_ptr145[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr145), 1, dest_len, src_ptr145[1..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr145), 3, src_ptr145[3..]); + ve(*const [0]u8, @as([*]const u8, src_ptr145), 3, 3, src_ptr145[3..3]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr145), 3, dest_end, src_ptr145[3..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr145), 0, src_ptr145[0.. :1]); + ve(*const [2:1]u8, @as([*]const u8, src_ptr145), 0, 2, src_ptr145[0..2 :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr145), 0, 1, src_ptr145[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*]const u8, src_ptr145), 0, dest_end, src_ptr145[0..dest_end :1]); + vl(*const [2:1]u8, @as([*]const u8, src_ptr145), 0, 2, src_ptr145[0..][0..2 :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr145), 0, 1, src_ptr145[0..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr145), 0, dest_len, src_ptr145[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr145), 1, src_ptr145[1.. :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr145), 1, 2, src_ptr145[1..2 :1]); + ve(*const [0:1]u8, @as([*]const u8, src_ptr145), 1, 1, src_ptr145[1..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr145), 1, dest_end, src_ptr145[1..dest_end :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr145), 1, 1, src_ptr145[1..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr145), 1, dest_len, src_ptr145[1..][0..dest_len :1]); + const src_ptr146: [*:0]const u8 = @ptrCast(&src_mem27); + vs([*]const u8, @as([*:0]const u8, src_ptr146), 0, src_ptr146[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr146), 0, 2, src_ptr146[0..2]); + ve(*const [3]u8, @as([*:0]const u8, src_ptr146), 0, 3, src_ptr146[0..3]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr146), 0, 1, src_ptr146[0..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr146), 0, dest_end, src_ptr146[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr146), 0, dest_end, src_ptr146[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr146), 0, 2, src_ptr146[0..][0..2]); + vl(*const [3]u8, @as([*:0]const u8, src_ptr146), 0, 3, src_ptr146[0..][0..3]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr146), 0, 1, src_ptr146[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*:0]const u8, src_ptr146), 0, dest_len, src_ptr146[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*:0]const u8, src_ptr146), 0, dest_len, src_ptr146[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr146), 1, src_ptr146[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr146), 1, 2, src_ptr146[1..2]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr146), 1, 3, src_ptr146[1..3]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr146), 1, 1, src_ptr146[1..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr146), 1, dest_end, src_ptr146[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr146), 1, dest_end, src_ptr146[1..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr146), 1, 2, src_ptr146[1..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr146), 1, 1, src_ptr146[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr146), 1, dest_len, src_ptr146[1..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr146), 3, src_ptr146[3..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr146), 3, 3, src_ptr146[3..3]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr146), 3, dest_end, src_ptr146[3..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr146), 0, src_ptr146[0.. :1]); + ve(*const [1:1]u8, @as([*:0]const u8, src_ptr146), 0, 1, src_ptr146[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*:0]const u8, src_ptr146), 0, dest_end, src_ptr146[0..dest_end :1]); + vl(*const [1:1]u8, @as([*:0]const u8, src_ptr146), 0, 1, src_ptr146[0..][0..1 :1]); + vl([:1]const u8, @as([*:0]const u8, src_ptr146), 0, dest_len, src_ptr146[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr146), 1, src_ptr146[1.. :1]); + ve(*const [0:1]u8, @as([*:0]const u8, src_ptr146), 1, 1, src_ptr146[1..1 :1]); + ve([:1]const u8, @as([*:0]const u8, src_ptr146), 1, dest_end, src_ptr146[1..dest_end :1]); + const src_ptr147: [*]const u8 = @ptrCast(&src_mem28); + vs([*]const u8, @as([*]const u8, src_ptr147), 0, src_ptr147[0..]); + ve(*const [1]u8, @as([*]const u8, src_ptr147), 0, 1, src_ptr147[0..1]); + ve([]const u8, @as([*]const u8, src_ptr147), 0, dest_end, src_ptr147[0..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr147), 0, 1, src_ptr147[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr147), 0, dest_len, src_ptr147[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr147), 1, src_ptr147[1..]); + ve(*const [0]u8, @as([*]const u8, src_ptr147), 1, 1, src_ptr147[1..1]); + ve([]const u8, @as([*]const u8, src_ptr147), 1, dest_end, src_ptr147[1..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr147), 0, src_ptr147[0.. :1]); + const src_ptr148: [*:0]const u8 = @ptrCast(&src_mem29); + vs([*]const u8, @as([*:0]const u8, src_ptr148), 0, src_ptr148[0..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr148), 0, 1, src_ptr148[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr148), 0, dest_end, src_ptr148[0..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr148), 0, 1, src_ptr148[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr148), 0, dest_len, src_ptr148[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr148), 1, src_ptr148[1..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr148), 1, 1, src_ptr148[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr148), 1, dest_end, src_ptr148[1..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr148), 0, src_ptr148[0.. :1]); + var src_ptr149: [*]const u8 = @ptrCast(&src_mem24); + vs([*]const u8, @as([*]const u8, src_ptr149), 0, src_ptr149[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr149), 0, 2, src_ptr149[0..2]); + ve(*const [1]u8, @as([*]const u8, src_ptr149), 0, 1, src_ptr149[0..1]); + ve([]const u8, @as([*]const u8, src_ptr149), 0, dest_end, src_ptr149[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr149), 0, 2, src_ptr149[0..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr149), 0, 1, src_ptr149[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr149), 0, dest_len, src_ptr149[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr149), 1, src_ptr149[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr149), 1, 2, src_ptr149[1..2]); + ve(*const [0]u8, @as([*]const u8, src_ptr149), 1, 1, src_ptr149[1..1]); + ve([]const u8, @as([*]const u8, src_ptr149), 1, dest_end, src_ptr149[1..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr149), 1, 1, src_ptr149[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr149), 1, dest_len, src_ptr149[1..][0..dest_len]); + vs([*:1]const u8, @as([*]const u8, src_ptr149), 0, src_ptr149[0.. :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr149), 0, 1, src_ptr149[0..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr149), 0, dest_end, src_ptr149[0..dest_end :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr149), 0, 1, src_ptr149[0..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr149), 0, dest_len, src_ptr149[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr149), 1, src_ptr149[1.. :1]); + ve(*const [0:1]u8, @as([*]const u8, src_ptr149), 1, 1, src_ptr149[1..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr149), 1, dest_end, src_ptr149[1..dest_end :1]); + var src_ptr150: [*:0]const u8 = @ptrCast(&src_mem25); + vs([*]const u8, @as([*:0]const u8, src_ptr150), 0, src_ptr150[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr150), 0, 2, src_ptr150[0..2]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr150), 0, 1, src_ptr150[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr150), 0, dest_end, src_ptr150[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr150), 0, 2, src_ptr150[0..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr150), 0, 1, src_ptr150[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr150), 0, dest_len, src_ptr150[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr150), 1, src_ptr150[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr150), 1, 2, src_ptr150[1..2]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr150), 1, 1, src_ptr150[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr150), 1, dest_end, src_ptr150[1..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr150), 1, 1, src_ptr150[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr150), 1, dest_len, src_ptr150[1..][0..dest_len]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr150), 0, src_ptr150[0.. :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr150), 1, src_ptr150[1.. :1]); + var src_ptr151: [*]const u8 = @ptrCast(&src_mem26); + vs([*]const u8, @as([*]const u8, src_ptr151), 0, src_ptr151[0..]); + ve(*const [2]u8, @as([*]const u8, src_ptr151), 0, 2, src_ptr151[0..2]); + ve(*const [3]u8, @as([*]const u8, src_ptr151), 0, 3, src_ptr151[0..3]); + ve(*const [1]u8, @as([*]const u8, src_ptr151), 0, 1, src_ptr151[0..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr151), 0, dest_end, src_ptr151[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr151), 0, dest_end, src_ptr151[0..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr151), 0, 2, src_ptr151[0..][0..2]); + vl(*const [3]u8, @as([*]const u8, src_ptr151), 0, 3, src_ptr151[0..][0..3]); + vl(*const [1]u8, @as([*]const u8, src_ptr151), 0, 1, src_ptr151[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*]const u8, src_ptr151), 0, dest_len, src_ptr151[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*]const u8, src_ptr151), 0, dest_len, src_ptr151[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr151), 1, src_ptr151[1..]); + ve(*const [1]u8, @as([*]const u8, src_ptr151), 1, 2, src_ptr151[1..2]); + ve(*const [2]u8, @as([*]const u8, src_ptr151), 1, 3, src_ptr151[1..3]); + ve(*const [0]u8, @as([*]const u8, src_ptr151), 1, 1, src_ptr151[1..1]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr151), 1, dest_end, src_ptr151[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*]const u8, src_ptr151), 1, dest_end, src_ptr151[1..dest_end]); + vl(*const [2]u8, @as([*]const u8, src_ptr151), 1, 2, src_ptr151[1..][0..2]); + vl(*const [1]u8, @as([*]const u8, src_ptr151), 1, 1, src_ptr151[1..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr151), 1, dest_len, src_ptr151[1..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr151), 3, src_ptr151[3..]); + ve(*const [0]u8, @as([*]const u8, src_ptr151), 3, 3, src_ptr151[3..3]); + dest_end = 3; + ve([]const u8, @as([*]const u8, src_ptr151), 3, dest_end, src_ptr151[3..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr151), 0, src_ptr151[0.. :1]); + ve(*const [2:1]u8, @as([*]const u8, src_ptr151), 0, 2, src_ptr151[0..2 :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr151), 0, 1, src_ptr151[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*]const u8, src_ptr151), 0, dest_end, src_ptr151[0..dest_end :1]); + vl(*const [2:1]u8, @as([*]const u8, src_ptr151), 0, 2, src_ptr151[0..][0..2 :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr151), 0, 1, src_ptr151[0..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr151), 0, dest_len, src_ptr151[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*]const u8, src_ptr151), 1, src_ptr151[1.. :1]); + ve(*const [1:1]u8, @as([*]const u8, src_ptr151), 1, 2, src_ptr151[1..2 :1]); + ve(*const [0:1]u8, @as([*]const u8, src_ptr151), 1, 1, src_ptr151[1..1 :1]); + ve([:1]const u8, @as([*]const u8, src_ptr151), 1, dest_end, src_ptr151[1..dest_end :1]); + vl(*const [1:1]u8, @as([*]const u8, src_ptr151), 1, 1, src_ptr151[1..][0..1 :1]); + vl([:1]const u8, @as([*]const u8, src_ptr151), 1, dest_len, src_ptr151[1..][0..dest_len :1]); + var src_ptr152: [*:0]const u8 = @ptrCast(&src_mem27); + vs([*]const u8, @as([*:0]const u8, src_ptr152), 0, src_ptr152[0..]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr152), 0, 2, src_ptr152[0..2]); + ve(*const [3]u8, @as([*:0]const u8, src_ptr152), 0, 3, src_ptr152[0..3]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr152), 0, 1, src_ptr152[0..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr152), 0, dest_end, src_ptr152[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr152), 0, dest_end, src_ptr152[0..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr152), 0, 2, src_ptr152[0..][0..2]); + vl(*const [3]u8, @as([*:0]const u8, src_ptr152), 0, 3, src_ptr152[0..][0..3]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr152), 0, 1, src_ptr152[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*:0]const u8, src_ptr152), 0, dest_len, src_ptr152[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*:0]const u8, src_ptr152), 0, dest_len, src_ptr152[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr152), 1, src_ptr152[1..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr152), 1, 2, src_ptr152[1..2]); + ve(*const [2]u8, @as([*:0]const u8, src_ptr152), 1, 3, src_ptr152[1..3]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr152), 1, 1, src_ptr152[1..1]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr152), 1, dest_end, src_ptr152[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*:0]const u8, src_ptr152), 1, dest_end, src_ptr152[1..dest_end]); + vl(*const [2]u8, @as([*:0]const u8, src_ptr152), 1, 2, src_ptr152[1..][0..2]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr152), 1, 1, src_ptr152[1..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr152), 1, dest_len, src_ptr152[1..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr152), 3, src_ptr152[3..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr152), 3, 3, src_ptr152[3..3]); + dest_end = 3; + ve([]const u8, @as([*:0]const u8, src_ptr152), 3, dest_end, src_ptr152[3..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr152), 0, src_ptr152[0.. :1]); + ve(*const [1:1]u8, @as([*:0]const u8, src_ptr152), 0, 1, src_ptr152[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*:0]const u8, src_ptr152), 0, dest_end, src_ptr152[0..dest_end :1]); + vl(*const [1:1]u8, @as([*:0]const u8, src_ptr152), 0, 1, src_ptr152[0..][0..1 :1]); + vl([:1]const u8, @as([*:0]const u8, src_ptr152), 0, dest_len, src_ptr152[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr152), 1, src_ptr152[1.. :1]); + ve(*const [0:1]u8, @as([*:0]const u8, src_ptr152), 1, 1, src_ptr152[1..1 :1]); + ve([:1]const u8, @as([*:0]const u8, src_ptr152), 1, dest_end, src_ptr152[1..dest_end :1]); + var src_ptr153: [*]const u8 = @ptrCast(&src_mem28); + vs([*]const u8, @as([*]const u8, src_ptr153), 0, src_ptr153[0..]); + ve(*const [1]u8, @as([*]const u8, src_ptr153), 0, 1, src_ptr153[0..1]); + ve([]const u8, @as([*]const u8, src_ptr153), 0, dest_end, src_ptr153[0..dest_end]); + vl(*const [1]u8, @as([*]const u8, src_ptr153), 0, 1, src_ptr153[0..][0..1]); + vl([]const u8, @as([*]const u8, src_ptr153), 0, dest_len, src_ptr153[0..][0..dest_len]); + vs([*]const u8, @as([*]const u8, src_ptr153), 1, src_ptr153[1..]); + ve(*const [0]u8, @as([*]const u8, src_ptr153), 1, 1, src_ptr153[1..1]); + ve([]const u8, @as([*]const u8, src_ptr153), 1, dest_end, src_ptr153[1..dest_end]); + vs([*:1]const u8, @as([*]const u8, src_ptr153), 0, src_ptr153[0.. :1]); + var src_ptr154: [*:0]const u8 = @ptrCast(&src_mem29); + vs([*]const u8, @as([*:0]const u8, src_ptr154), 0, src_ptr154[0..]); + ve(*const [1]u8, @as([*:0]const u8, src_ptr154), 0, 1, src_ptr154[0..1]); + ve([]const u8, @as([*:0]const u8, src_ptr154), 0, dest_end, src_ptr154[0..dest_end]); + vl(*const [1]u8, @as([*:0]const u8, src_ptr154), 0, 1, src_ptr154[0..][0..1]); + vl([]const u8, @as([*:0]const u8, src_ptr154), 0, dest_len, src_ptr154[0..][0..dest_len]); + vs([*]const u8, @as([*:0]const u8, src_ptr154), 1, src_ptr154[1..]); + ve(*const [0]u8, @as([*:0]const u8, src_ptr154), 1, 1, src_ptr154[1..1]); + ve([]const u8, @as([*:0]const u8, src_ptr154), 1, dest_end, src_ptr154[1..dest_end]); + vs([*:1]const u8, @as([*:0]const u8, src_ptr154), 0, src_ptr154[0.. :1]); + const src_ptr155: [*c]const u8 = @ptrCast(&src_mem24); + vs([*c]const u8, @as([*c]const u8, src_ptr155), 0, src_ptr155[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr155), 0, 2, src_ptr155[0..2]); + ve(*const [1]u8, @as([*c]const u8, src_ptr155), 0, 1, src_ptr155[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr155), 0, dest_end, src_ptr155[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr155), 0, 2, src_ptr155[0..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr155), 0, 1, src_ptr155[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr155), 0, dest_len, src_ptr155[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr155), 1, src_ptr155[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr155), 1, 2, src_ptr155[1..2]); + ve(*const [0]u8, @as([*c]const u8, src_ptr155), 1, 1, src_ptr155[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr155), 1, dest_end, src_ptr155[1..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr155), 1, 1, src_ptr155[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr155), 1, dest_len, src_ptr155[1..][0..dest_len]); + vs([*:1]const u8, @as([*c]const u8, src_ptr155), 0, src_ptr155[0.. :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr155), 0, 1, src_ptr155[0..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr155), 0, dest_end, src_ptr155[0..dest_end :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr155), 0, 1, src_ptr155[0..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr155), 0, dest_len, src_ptr155[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr155), 1, src_ptr155[1.. :1]); + ve(*const [0:1]u8, @as([*c]const u8, src_ptr155), 1, 1, src_ptr155[1..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr155), 1, dest_end, src_ptr155[1..dest_end :1]); + const src_ptr156: [*c]const u8 = @ptrCast(&src_mem26); + vs([*c]const u8, @as([*c]const u8, src_ptr156), 0, src_ptr156[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr156), 0, 2, src_ptr156[0..2]); + ve(*const [3]u8, @as([*c]const u8, src_ptr156), 0, 3, src_ptr156[0..3]); + ve(*const [1]u8, @as([*c]const u8, src_ptr156), 0, 1, src_ptr156[0..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr156), 0, dest_end, src_ptr156[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr156), 0, dest_end, src_ptr156[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr156), 0, 2, src_ptr156[0..][0..2]); + vl(*const [3]u8, @as([*c]const u8, src_ptr156), 0, 3, src_ptr156[0..][0..3]); + vl(*const [1]u8, @as([*c]const u8, src_ptr156), 0, 1, src_ptr156[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*c]const u8, src_ptr156), 0, dest_len, src_ptr156[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*c]const u8, src_ptr156), 0, dest_len, src_ptr156[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr156), 1, src_ptr156[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr156), 1, 2, src_ptr156[1..2]); + ve(*const [2]u8, @as([*c]const u8, src_ptr156), 1, 3, src_ptr156[1..3]); + ve(*const [0]u8, @as([*c]const u8, src_ptr156), 1, 1, src_ptr156[1..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr156), 1, dest_end, src_ptr156[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr156), 1, dest_end, src_ptr156[1..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr156), 1, 2, src_ptr156[1..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr156), 1, 1, src_ptr156[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr156), 1, dest_len, src_ptr156[1..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr156), 3, src_ptr156[3..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr156), 3, 3, src_ptr156[3..3]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr156), 3, dest_end, src_ptr156[3..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr156), 0, src_ptr156[0.. :1]); + ve(*const [2:1]u8, @as([*c]const u8, src_ptr156), 0, 2, src_ptr156[0..2 :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr156), 0, 1, src_ptr156[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*c]const u8, src_ptr156), 0, dest_end, src_ptr156[0..dest_end :1]); + vl(*const [2:1]u8, @as([*c]const u8, src_ptr156), 0, 2, src_ptr156[0..][0..2 :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr156), 0, 1, src_ptr156[0..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr156), 0, dest_len, src_ptr156[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr156), 1, src_ptr156[1.. :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr156), 1, 2, src_ptr156[1..2 :1]); + ve(*const [0:1]u8, @as([*c]const u8, src_ptr156), 1, 1, src_ptr156[1..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr156), 1, dest_end, src_ptr156[1..dest_end :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr156), 1, 1, src_ptr156[1..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr156), 1, dest_len, src_ptr156[1..][0..dest_len :1]); + const src_ptr157: [*c]const u8 = @ptrCast(&src_mem28); + vs([*c]const u8, @as([*c]const u8, src_ptr157), 0, src_ptr157[0..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr157), 0, 1, src_ptr157[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr157), 0, dest_end, src_ptr157[0..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr157), 0, 1, src_ptr157[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr157), 0, dest_len, src_ptr157[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr157), 1, src_ptr157[1..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr157), 1, 1, src_ptr157[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr157), 1, dest_end, src_ptr157[1..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr157), 0, src_ptr157[0.. :1]); + var src_ptr158: [*c]const u8 = @ptrCast(&src_mem24); + vs([*c]const u8, @as([*c]const u8, src_ptr158), 0, src_ptr158[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr158), 0, 2, src_ptr158[0..2]); + ve(*const [1]u8, @as([*c]const u8, src_ptr158), 0, 1, src_ptr158[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr158), 0, dest_end, src_ptr158[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr158), 0, 2, src_ptr158[0..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr158), 0, 1, src_ptr158[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr158), 0, dest_len, src_ptr158[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr158), 1, src_ptr158[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr158), 1, 2, src_ptr158[1..2]); + ve(*const [0]u8, @as([*c]const u8, src_ptr158), 1, 1, src_ptr158[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr158), 1, dest_end, src_ptr158[1..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr158), 1, 1, src_ptr158[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr158), 1, dest_len, src_ptr158[1..][0..dest_len]); + vs([*:1]const u8, @as([*c]const u8, src_ptr158), 0, src_ptr158[0.. :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr158), 0, 1, src_ptr158[0..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr158), 0, dest_end, src_ptr158[0..dest_end :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr158), 0, 1, src_ptr158[0..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr158), 0, dest_len, src_ptr158[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr158), 1, src_ptr158[1.. :1]); + ve(*const [0:1]u8, @as([*c]const u8, src_ptr158), 1, 1, src_ptr158[1..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr158), 1, dest_end, src_ptr158[1..dest_end :1]); + var src_ptr159: [*c]const u8 = @ptrCast(&src_mem26); + vs([*c]const u8, @as([*c]const u8, src_ptr159), 0, src_ptr159[0..]); + ve(*const [2]u8, @as([*c]const u8, src_ptr159), 0, 2, src_ptr159[0..2]); + ve(*const [3]u8, @as([*c]const u8, src_ptr159), 0, 3, src_ptr159[0..3]); + ve(*const [1]u8, @as([*c]const u8, src_ptr159), 0, 1, src_ptr159[0..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr159), 0, dest_end, src_ptr159[0..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr159), 0, dest_end, src_ptr159[0..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr159), 0, 2, src_ptr159[0..][0..2]); + vl(*const [3]u8, @as([*c]const u8, src_ptr159), 0, 3, src_ptr159[0..][0..3]); + vl(*const [1]u8, @as([*c]const u8, src_ptr159), 0, 1, src_ptr159[0..][0..1]); + dest_len = 3; + vl([]const u8, @as([*c]const u8, src_ptr159), 0, dest_len, src_ptr159[0..][0..dest_len]); + dest_len = 1; + vl([]const u8, @as([*c]const u8, src_ptr159), 0, dest_len, src_ptr159[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr159), 1, src_ptr159[1..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr159), 1, 2, src_ptr159[1..2]); + ve(*const [2]u8, @as([*c]const u8, src_ptr159), 1, 3, src_ptr159[1..3]); + ve(*const [0]u8, @as([*c]const u8, src_ptr159), 1, 1, src_ptr159[1..1]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr159), 1, dest_end, src_ptr159[1..dest_end]); + dest_end = 1; + ve([]const u8, @as([*c]const u8, src_ptr159), 1, dest_end, src_ptr159[1..dest_end]); + vl(*const [2]u8, @as([*c]const u8, src_ptr159), 1, 2, src_ptr159[1..][0..2]); + vl(*const [1]u8, @as([*c]const u8, src_ptr159), 1, 1, src_ptr159[1..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr159), 1, dest_len, src_ptr159[1..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr159), 3, src_ptr159[3..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr159), 3, 3, src_ptr159[3..3]); + dest_end = 3; + ve([]const u8, @as([*c]const u8, src_ptr159), 3, dest_end, src_ptr159[3..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr159), 0, src_ptr159[0.. :1]); + ve(*const [2:1]u8, @as([*c]const u8, src_ptr159), 0, 2, src_ptr159[0..2 :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr159), 0, 1, src_ptr159[0..1 :1]); + dest_end = 1; + ve([:1]const u8, @as([*c]const u8, src_ptr159), 0, dest_end, src_ptr159[0..dest_end :1]); + vl(*const [2:1]u8, @as([*c]const u8, src_ptr159), 0, 2, src_ptr159[0..][0..2 :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr159), 0, 1, src_ptr159[0..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr159), 0, dest_len, src_ptr159[0..][0..dest_len :1]); + vs([*:1]const u8, @as([*c]const u8, src_ptr159), 1, src_ptr159[1.. :1]); + ve(*const [1:1]u8, @as([*c]const u8, src_ptr159), 1, 2, src_ptr159[1..2 :1]); + ve(*const [0:1]u8, @as([*c]const u8, src_ptr159), 1, 1, src_ptr159[1..1 :1]); + ve([:1]const u8, @as([*c]const u8, src_ptr159), 1, dest_end, src_ptr159[1..dest_end :1]); + vl(*const [1:1]u8, @as([*c]const u8, src_ptr159), 1, 1, src_ptr159[1..][0..1 :1]); + vl([:1]const u8, @as([*c]const u8, src_ptr159), 1, dest_len, src_ptr159[1..][0..dest_len :1]); + var src_ptr160: [*c]const u8 = @ptrCast(&src_mem28); + vs([*c]const u8, @as([*c]const u8, src_ptr160), 0, src_ptr160[0..]); + ve(*const [1]u8, @as([*c]const u8, src_ptr160), 0, 1, src_ptr160[0..1]); + ve([]const u8, @as([*c]const u8, src_ptr160), 0, dest_end, src_ptr160[0..dest_end]); + vl(*const [1]u8, @as([*c]const u8, src_ptr160), 0, 1, src_ptr160[0..][0..1]); + vl([]const u8, @as([*c]const u8, src_ptr160), 0, dest_len, src_ptr160[0..][0..dest_len]); + vs([*c]const u8, @as([*c]const u8, src_ptr160), 1, src_ptr160[1..]); + ve(*const [0]u8, @as([*c]const u8, src_ptr160), 1, 1, src_ptr160[1..1]); + ve([]const u8, @as([*c]const u8, src_ptr160), 1, dest_end, src_ptr160[1..dest_end]); + vs([*:1]const u8, @as([*c]const u8, src_ptr160), 0, src_ptr160[0.. :1]); +} +const std = @import("std"); +fn vs( + comptime return_ty: type, + ptr: anytype, + start: usize, + res: anytype, +) void { + @setRuntimeSafety(false); + if (return_ty != @TypeOf(res)) { + std.debug.panic("{any}", .{.{ .input = @TypeOf(ptr), .expected = return_ty, .found = @TypeOf(res) }}); + } + if (manyPtr(ptr) + start != manyPtr(res)) { + std.debug.panic("{any}", .{.{ .expected = manyPtr(ptr) + start, .found = manyPtr(res) }}); + } + if (badLen(ptr, start, res)) |bad_len| { + std.debug.panic("{any}", .{bad_len}); + } + testMem(res); +} +fn ve( + comptime return_ty: type, + ptr: anytype, + start: usize, + end: usize, + res: anytype, +) void { + @setRuntimeSafety(false); + if (return_ty != @TypeOf(res)) { + std.debug.panic("{any}", .{.{ .input = @TypeOf(ptr), .expected = return_ty, .found = @TypeOf(res) }}); + } + if (manyPtr(ptr) + start != manyPtr(res)) { + std.debug.panic("{any}", .{.{ .expected = manyPtr(ptr) + start, .found = manyPtr(res) }}); + } + if (end - start != res.len) { + std.debug.panic("{any}", .{.{ .expected = end - start, .found = res.len }}); + } + if (badSentinel(res)) |sent| { + std.debug.panic("{any}", .{sent}); + } + testMem(res); +} +fn vl( + comptime return_ty: type, + ptr: anytype, + start: usize, + len: usize, + res: anytype, +) void { + @setRuntimeSafety(false); + if (return_ty != @TypeOf(res)) { + std.debug.panic("{any}", .{.{ .input = @TypeOf(ptr), .expected = return_ty, .found = @TypeOf(res) }}); + } + if (manyPtr(ptr) + start != manyPtr(res)) { + std.debug.panic("{any}", .{.{ .expected = manyPtr(ptr) + start, .found = manyPtr(res) }}); + } + if (len != res.len) { + std.debug.panic("{any}", .{.{ .expected = len, .found = res.len }}); + } + if (badSentinel(res)) |sent| { + std.debug.panic("{any}", .{sent}); + } + testMem(res); +} +inline fn manyPtr(ptr: anytype) [*]const std.meta.Elem(@TypeOf(ptr)) { + @setRuntimeSafety(false); + switch (@typeInfo(@TypeOf(ptr)).Pointer.size) { + .Slice => { + return @ptrCast(ptr.ptr); + }, + else => { + return @ptrCast(ptr); + }, + } +} +inline fn testMem(res: anytype) void { + switch (@typeInfo(@TypeOf(res)).Pointer.size) { + .Slice, .One => { + if (!@typeInfo(@TypeOf(res)).Pointer.is_const) { + for (res, 0..) |*val, idx| val.* = res[idx]; + } + }, + else => {}, + } +} +inline fn badLen(ptr: anytype, start: usize, res: anytype) ?struct { expected: usize, found: usize } { + @setRuntimeSafety(false); + switch (@typeInfo(@TypeOf(ptr)).Pointer.size) { + .Slice, .One => if (ptr.len - start != res.len) { + return .{ .expected = ptr.len - start, .found = res.len }; + }, + else => return null, + } + return null; +} +inline fn badSentinel(res: anytype) ?struct { expected: std.meta.Elem(@TypeOf(res)), found: std.meta.Elem(@TypeOf(res)) } { + @setRuntimeSafety(false); + switch (@typeInfo(@TypeOf(res)).Pointer.size) { + .Slice, .One => if (std.meta.sentinel(@TypeOf(res))) |sent| if (res[res.len] != sent) { + return .{ .expected = sent, .found = res.ptr[res.len] }; + }, + else => return null, + } + return null; +} +test { + if (@import("builtin").zig_backend == .stage2_riscv64) return error.SkipZigTest; + fn0(); + fn1(); + fn2(); + fn3(); + fn4(); + fn5(); + fn6(); + fn7(); + fn8(); +} diff --git a/test/behavior/slice_sentinel_comptime.zig b/test/behavior/slice_sentinel_comptime.zig index 51cf7d428bee..5f1683e53eb9 100644 --- a/test/behavior/slice_sentinel_comptime.zig +++ b/test/behavior/slice_sentinel_comptime.zig @@ -222,7 +222,7 @@ test "comptime slice-sentinel in bounds (on target sentinel)" { // slice comptime { var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10; - var target: []u8 = &buf; + var target: [:0]u8 = &buf; const slice = target[0..14 :0]; _ = slice; } diff --git a/test/behavior/void.zig b/test/behavior/void.zig index 5c4215b87042..f5730d91dac0 100644 --- a/test/behavior/void.zig +++ b/test/behavior/void.zig @@ -18,21 +18,6 @@ test "compare void with void compile time known" { } } -test "iterate over a void slice" { - if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; - - var j: usize = 0; - for (times(10), 0..) |_, i| { - try expect(i == j); - j += 1; - } -} - -fn times(n: usize) []const void { - return @as([*]void, undefined)[0..n]; -} - test "void optional" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; diff --git a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig index 83c48e8acd57..fae9b107b951 100644 --- a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig +++ b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_terminated.zig @@ -58,17 +58,10 @@ export fn foo_slice() void { // backend=stage2 // target=native // -// :4:29: error: value in memory does not match slice sentinel -// :4:29: note: expected '0', found '100' -// :12:29: error: value in memory does not match slice sentinel -// :12:29: note: expected '0', found '100' -// :20:29: error: value in memory does not match slice sentinel -// :20:29: note: expected '0', found '100' -// :28:29: error: value in memory does not match slice sentinel -// :28:29: note: expected '0', found '100' -// :36:29: error: value in memory does not match slice sentinel -// :36:29: note: expected '0', found '100' -// :44:29: error: value in memory does not match slice sentinel -// :44:29: note: expected '0', found '100' -// :52:29: error: value in memory does not match slice sentinel -// :52:29: note: expected '0', found '100' +// :4:36: error: mismatched sentinel: expected 0, found 100 +// :12:36: error: mismatched sentinel: expected 0, found 100 +// :20:36: error: mismatched sentinel: expected 0, found 100 +// :28:36: error: mismatched sentinel: expected 0, found 100 +// :36:36: error: mismatched sentinel: expected 0, found 100 +// :44:36: error: mismatched sentinel: expected 0, found 100 +// :52:36: error: mismatched sentinel: expected 0, found 100 diff --git a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig index c111b026a501..d3512f928eb6 100644 --- a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig +++ b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_memory_at_target_index_unterminated.zig @@ -58,17 +58,10 @@ export fn foo_slice() void { // backend=stage2 // target=native // -// :4:29: error: value in memory does not match slice sentinel -// :4:29: note: expected '0', found '100' -// :12:29: error: value in memory does not match slice sentinel -// :12:29: note: expected '0', found '100' -// :20:29: error: value in memory does not match slice sentinel -// :20:29: note: expected '0', found '100' -// :28:29: error: value in memory does not match slice sentinel -// :28:29: note: expected '0', found '100' -// :36:29: error: value in memory does not match slice sentinel -// :36:29: note: expected '0', found '100' -// :44:29: error: value in memory does not match slice sentinel -// :44:29: note: expected '0', found '100' -// :52:29: error: value in memory does not match slice sentinel -// :52:29: note: expected '0', found '100' +// :4:36: error: mismatched sentinel: expected 0, found 100 +// :12:36: error: mismatched sentinel: expected 0, found 100 +// :20:36: error: mismatched sentinel: expected 0, found 100 +// :28:36: error: mismatched sentinel: expected 0, found 100 +// :36:36: error: mismatched sentinel: expected 0, found 100 +// :44:36: error: mismatched sentinel: expected 0, found 100 +// :52:36: error: mismatched sentinel: expected 0, found 100 diff --git a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_target-sentinel.zig b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_target-sentinel.zig index 24aa36949b46..ffbb0f0fac32 100644 --- a/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_target-sentinel.zig +++ b/test/cases/compile_errors/comptime_slice-sentinel_does_not_match_target-sentinel.zig @@ -48,7 +48,7 @@ export fn foo_cvector_ConstPtrSpecialRef() void { export fn foo_slice() void { comptime { var buf = [_:0]u8{ 'a', 'b', 'c', 'd' } ++ [_]u8{undefined} ** 10; - var target: []u8 = &buf; + var target: [:0]u8 = &buf; const slice = target[0..14 :255]; _ = slice; } @@ -73,23 +73,13 @@ export fn typeName_slice() void { // backend=stage2 // target=native // -// :4:29: error: value in memory does not match slice sentinel -// :4:29: note: expected '255', found '0' -// :12:29: error: value in memory does not match slice sentinel -// :12:29: note: expected '255', found '0' -// :20:29: error: value in memory does not match slice sentinel -// :20:29: note: expected '255', found '0' -// :28:29: error: value in memory does not match slice sentinel -// :28:29: note: expected '255', found '0' -// :36:29: error: value in memory does not match slice sentinel -// :36:29: note: expected '255', found '0' -// :44:29: error: value in memory does not match slice sentinel -// :44:29: note: expected '255', found '0' -// :52:29: error: value in memory does not match slice sentinel -// :52:29: note: expected '255', found '0' -// :58:22: error: value in memory does not match slice sentinel -// :58:22: note: expected '0', found 'undefined' -// :63:22: error: value in memory does not match slice sentinel -// :63:22: note: expected '12', found '98' -// :68:22: error: value in memory does not match slice sentinel -// :68:22: note: expected '0', found '105' +// :4:37: error: mismatched sentinel: expected 255, found 0 +// :12:37: error: mismatched sentinel: expected 255, found 0 +// :20:37: error: mismatched sentinel: expected 255, found 0 +// :28:37: error: mismatched sentinel: expected 255, found 0 +// :36:37: error: mismatched sentinel: expected 255, found 0 +// :44:37: error: mismatched sentinel: expected 255, found 0 +// :52:37: error: mismatched sentinel: expected 255, found 0 +// :58:30: error: mismatched sentinel: expected 0, found undefined +// :63:29: error: mismatched sentinel: expected 12, found 98 +// :68:29: error: mismatched sentinel: expected 0, found 105 diff --git a/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_terminated.zig b/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_terminated.zig index 249d59414afd..8c22e86526f7 100644 --- a/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_terminated.zig +++ b/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_terminated.zig @@ -58,10 +58,10 @@ export fn foo_slice() void { // backend=stage2 // target=native // -// :4:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :12:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :20:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :28:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :36:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :44:33: error: slice end index 15 exceeds bounds of containing decl of type '[14:0]u8' -// :52:33: error: end index 15 out of bounds for slice of length 14 +// :4:33: error: slice end out of bounds: end 15, length 14 +// :12:33: error: slice end out of bounds: end 15, length 14 +// :20:33: error: slice sentinel out of bounds of reinterpreted memory: end 15(+1), length 15 +// :28:33: error: slice sentinel out of bounds of reinterpreted memory: end 15(+1), length 15 +// :36:33: error: slice sentinel out of bounds of reinterpreted memory: end 15(+1), length 15 +// :44:33: error: slice sentinel out of bounds of reinterpreted memory: end 15(+1), length 15 +// :52:33: error: slice end out of bounds: end 15(+1), length 14 diff --git a/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig b/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig index a6e599ca3872..ab68ebfabf96 100644 --- a/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig +++ b/test/cases/compile_errors/comptime_slice-sentinel_is_out_of_bounds_unterminated.zig @@ -58,10 +58,10 @@ export fn foo_slice() void { // backend=stage2 // target=native // -// :4:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :12:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :20:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :28:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :36:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :44:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' -// :52:33: error: slice end index 14 exceeds bounds of containing decl of type '[14]u8' +// :4:33: error: slice sentinel out of bounds: end 14(+1), length 14 +// :12:33: error: slice sentinel out of bounds: end 14(+1), length 14 +// :20:33: error: slice sentinel out of bounds of reinterpreted memory: end 14(+1), length 14 +// :28:33: error: slice sentinel out of bounds of reinterpreted memory: end 14(+1), length 14 +// :36:33: error: slice sentinel out of bounds of reinterpreted memory: end 14(+1), length 14 +// :44:33: error: slice sentinel out of bounds of reinterpreted memory: end 14(+1), length 14 +// :52:33: error: slice sentinel out of bounds: end 14(+1), length 14 diff --git a/test/cases/compile_errors/comptime_slice_of_an_undefined_slice.zig b/test/cases/compile_errors/comptime_slice_of_an_undefined_slice.zig index aa3719816c69..3ba4a292257c 100644 --- a/test/cases/compile_errors/comptime_slice_of_an_undefined_slice.zig +++ b/test/cases/compile_errors/comptime_slice_of_an_undefined_slice.zig @@ -8,4 +8,4 @@ comptime { // backend=stage2 // target=native // -// :3:14: error: slice of undefined +// :3:14: error: non-zero length slice of undefined pointer diff --git a/test/cases/compile_errors/out_of_bounds_index.zig b/test/cases/compile_errors/out_of_bounds_index.zig index 29b5c7d7d124..5c34ff5379af 100644 --- a/test/cases/compile_errors/out_of_bounds_index.zig +++ b/test/cases/compile_errors/out_of_bounds_index.zig @@ -23,7 +23,7 @@ comptime { // error // target=native // -// :4:32: error: end index 6 out of bounds for slice of length 4 +1 (sentinel) -// :9:28: error: end index 6 out of bounds for array of length 4 +1 (sentinel) -// :14:28: error: end index 5 out of bounds for array of length 4 -// :19:25: error: start index 3 is larger than end index 2 +// :4:32: error: slice end out of bounds: end 6, length 5 +// :9:28: error: slice end out of bounds: end 6, length 5 +// :14:28: error: slice end out of bounds: end 5, length 4 +// :19:25: error: bounds out of order: start 3, end 2 diff --git a/test/cases/compile_errors/panic_has_source_location.zig b/test/cases/compile_errors/panic_has_source_location.zig index 6e9d16d76d24..a501c6e94f71 100644 --- a/test/cases/compile_errors/panic_has_source_location.zig +++ b/test/cases/compile_errors/panic_has_source_location.zig @@ -6,7 +6,7 @@ export fn foo() void { @panic("oh no"); } -pub fn panic(_: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn { +pub fn panic2(_: std.builtin.PanicCause, _: anytype) noreturn { @compileError("panic"); } diff --git a/test/cases/compile_errors/slice_compile_error_variants.zig b/test/cases/compile_errors/slice_compile_error_variants.zig new file mode 100644 index 000000000000..7755b1b80b0f --- /dev/null +++ b/test/cases/compile_errors/slice_compile_error_variants.zig @@ -0,0 +1,18070 @@ +var dest_end: usize = 0; +var dest_start: usize = 0; +var dest_len: usize = 0; +var src_mem0: [2]u8 = undefined; +const src_ptr0: *[2]u8 = src_mem0[0..2]; +export fn fn0() void { + _ = src_ptr0[0..3]; +} +export fn fn1() void { + _ = src_ptr0[0..][0..3]; +} +export fn fn2() void { + _ = src_ptr0[1..3]; +} +export fn fn3() void { + _ = src_ptr0[1..][0..2]; +} +export fn fn4() void { + _ = src_ptr0[1..][0..3]; +} +export fn fn5() void { + _ = src_ptr0[3..]; +} +export fn fn6() void { + _ = src_ptr0[3..2]; +} +export fn fn7() void { + _ = src_ptr0[3..3]; +} +export fn fn8() void { + _ = src_ptr0[3..1]; +} +export fn fn9() void { + dest_end = 3; + _ = src_ptr0[3..dest_end]; +} +export fn fn10() void { + dest_end = 1; + _ = src_ptr0[3..dest_end]; +} +export fn fn11() void { + _ = src_ptr0[3..][0..2]; +} +export fn fn12() void { + _ = src_ptr0[3..][0..3]; +} +export fn fn13() void { + _ = src_ptr0[3..][0..1]; +} +export fn fn14() void { + dest_len = 3; + _ = src_ptr0[3..][0..dest_len]; +} +export fn fn15() void { + dest_len = 1; + _ = src_ptr0[3..][0..dest_len]; +} +var src_mem1: [3]u8 = undefined; +const src_ptr1: *[3]u8 = src_mem1[0..3]; +export fn fn16() void { + _ = src_ptr1[1..][0..3]; +} +export fn fn17() void { + _ = src_ptr1[3..2]; +} +export fn fn18() void { + _ = src_ptr1[3..1]; +} +export fn fn19() void { + _ = src_ptr1[3..][0..2]; +} +export fn fn20() void { + _ = src_ptr1[3..][0..3]; +} +export fn fn21() void { + _ = src_ptr1[3..][0..1]; +} +var src_mem2: [1]u8 = undefined; +const src_ptr2: *[1]u8 = src_mem2[0..1]; +export fn fn22() void { + _ = src_ptr2[0..2]; +} +export fn fn23() void { + _ = src_ptr2[0..3]; +} +export fn fn24() void { + _ = src_ptr2[0..][0..2]; +} +export fn fn25() void { + _ = src_ptr2[0..][0..3]; +} +export fn fn26() void { + _ = src_ptr2[1..2]; +} +export fn fn27() void { + _ = src_ptr2[1..3]; +} +export fn fn28() void { + _ = src_ptr2[1..][0..2]; +} +export fn fn29() void { + _ = src_ptr2[1..][0..3]; +} +export fn fn30() void { + _ = src_ptr2[1..][0..1]; +} +export fn fn31() void { + _ = src_ptr2[3..]; +} +export fn fn32() void { + _ = src_ptr2[3..2]; +} +export fn fn33() void { + _ = src_ptr2[3..3]; +} +export fn fn34() void { + _ = src_ptr2[3..1]; +} +export fn fn35() void { + dest_end = 3; + _ = src_ptr2[3..dest_end]; +} +export fn fn36() void { + dest_end = 1; + _ = src_ptr2[3..dest_end]; +} +export fn fn37() void { + _ = src_ptr2[3..][0..2]; +} +export fn fn38() void { + _ = src_ptr2[3..][0..3]; +} +export fn fn39() void { + _ = src_ptr2[3..][0..1]; +} +export fn fn40() void { + dest_len = 3; + _ = src_ptr2[3..][0..dest_len]; +} +export fn fn41() void { + dest_len = 1; + _ = src_ptr2[3..][0..dest_len]; +} +var src_mem3: [2]u8 = undefined; +var src_ptr3: *[2]u8 = src_mem3[0..2]; +export fn fn42() void { + _ = src_ptr3[0..3]; +} +export fn fn43() void { + _ = src_ptr3[0..][0..3]; +} +export fn fn44() void { + _ = src_ptr3[1..3]; +} +export fn fn45() void { + _ = src_ptr3[1..][0..2]; +} +export fn fn46() void { + _ = src_ptr3[1..][0..3]; +} +export fn fn47() void { + _ = src_ptr3[3..]; +} +export fn fn48() void { + _ = src_ptr3[3..2]; +} +export fn fn49() void { + _ = src_ptr3[3..3]; +} +export fn fn50() void { + _ = src_ptr3[3..1]; +} +export fn fn51() void { + dest_end = 3; + _ = src_ptr3[3..dest_end]; +} +export fn fn52() void { + dest_end = 1; + _ = src_ptr3[3..dest_end]; +} +export fn fn53() void { + _ = src_ptr3[3..][0..2]; +} +export fn fn54() void { + _ = src_ptr3[3..][0..3]; +} +export fn fn55() void { + _ = src_ptr3[3..][0..1]; +} +export fn fn56() void { + dest_len = 3; + _ = src_ptr3[3..][0..dest_len]; +} +export fn fn57() void { + dest_len = 1; + _ = src_ptr3[3..][0..dest_len]; +} +var src_mem4: [3]u8 = undefined; +var src_ptr4: *[3]u8 = src_mem4[0..3]; +export fn fn58() void { + _ = src_ptr4[1..][0..3]; +} +export fn fn59() void { + _ = src_ptr4[3..2]; +} +export fn fn60() void { + _ = src_ptr4[3..1]; +} +export fn fn61() void { + _ = src_ptr4[3..][0..2]; +} +export fn fn62() void { + _ = src_ptr4[3..][0..3]; +} +export fn fn63() void { + _ = src_ptr4[3..][0..1]; +} +var src_mem5: [1]u8 = undefined; +var src_ptr5: *[1]u8 = src_mem5[0..1]; +export fn fn64() void { + _ = src_ptr5[0..2]; +} +export fn fn65() void { + _ = src_ptr5[0..3]; +} +export fn fn66() void { + _ = src_ptr5[0..][0..2]; +} +export fn fn67() void { + _ = src_ptr5[0..][0..3]; +} +export fn fn68() void { + _ = src_ptr5[1..2]; +} +export fn fn69() void { + _ = src_ptr5[1..3]; +} +export fn fn70() void { + _ = src_ptr5[1..][0..2]; +} +export fn fn71() void { + _ = src_ptr5[1..][0..3]; +} +export fn fn72() void { + _ = src_ptr5[1..][0..1]; +} +export fn fn73() void { + _ = src_ptr5[3..]; +} +export fn fn74() void { + _ = src_ptr5[3..2]; +} +export fn fn75() void { + _ = src_ptr5[3..3]; +} +export fn fn76() void { + _ = src_ptr5[3..1]; +} +export fn fn77() void { + dest_end = 3; + _ = src_ptr5[3..dest_end]; +} +export fn fn78() void { + dest_end = 1; + _ = src_ptr5[3..dest_end]; +} +export fn fn79() void { + _ = src_ptr5[3..][0..2]; +} +export fn fn80() void { + _ = src_ptr5[3..][0..3]; +} +export fn fn81() void { + _ = src_ptr5[3..][0..1]; +} +export fn fn82() void { + dest_len = 3; + _ = src_ptr5[3..][0..dest_len]; +} +export fn fn83() void { + dest_len = 1; + _ = src_ptr5[3..][0..dest_len]; +} +const src_ptr6: []u8 = src_mem0[0..2]; +export fn fn84() void { + _ = src_ptr6[0..3]; +} +export fn fn85() void { + _ = src_ptr6[0..][0..3]; +} +export fn fn86() void { + _ = src_ptr6[1..3]; +} +export fn fn87() void { + _ = src_ptr6[1..][0..2]; +} +export fn fn88() void { + _ = src_ptr6[1..][0..3]; +} +export fn fn89() void { + _ = src_ptr6[3..]; +} +export fn fn90() void { + _ = src_ptr6[3..2]; +} +export fn fn91() void { + _ = src_ptr6[3..3]; +} +export fn fn92() void { + _ = src_ptr6[3..1]; +} +export fn fn93() void { + dest_end = 3; + _ = src_ptr6[3..dest_end]; +} +export fn fn94() void { + dest_end = 1; + _ = src_ptr6[3..dest_end]; +} +export fn fn95() void { + _ = src_ptr6[3..][0..2]; +} +export fn fn96() void { + _ = src_ptr6[3..][0..3]; +} +export fn fn97() void { + _ = src_ptr6[3..][0..1]; +} +export fn fn98() void { + dest_len = 3; + _ = src_ptr6[3..][0..dest_len]; +} +export fn fn99() void { + dest_len = 1; + _ = src_ptr6[3..][0..dest_len]; +} +const src_ptr7: []u8 = src_mem1[0..3]; +export fn fn100() void { + _ = src_ptr7[1..][0..3]; +} +export fn fn101() void { + _ = src_ptr7[3..2]; +} +export fn fn102() void { + _ = src_ptr7[3..1]; +} +export fn fn103() void { + _ = src_ptr7[3..][0..2]; +} +export fn fn104() void { + _ = src_ptr7[3..][0..3]; +} +export fn fn105() void { + _ = src_ptr7[3..][0..1]; +} +const src_ptr8: []u8 = src_mem2[0..1]; +export fn fn106() void { + _ = src_ptr8[0..2]; +} +export fn fn107() void { + _ = src_ptr8[0..3]; +} +export fn fn108() void { + _ = src_ptr8[0..][0..2]; +} +export fn fn109() void { + _ = src_ptr8[0..][0..3]; +} +export fn fn110() void { + _ = src_ptr8[1..2]; +} +export fn fn111() void { + _ = src_ptr8[1..3]; +} +export fn fn112() void { + _ = src_ptr8[1..][0..2]; +} +export fn fn113() void { + _ = src_ptr8[1..][0..3]; +} +export fn fn114() void { + _ = src_ptr8[1..][0..1]; +} +export fn fn115() void { + _ = src_ptr8[3..]; +} +export fn fn116() void { + _ = src_ptr8[3..2]; +} +export fn fn117() void { + _ = src_ptr8[3..3]; +} +export fn fn118() void { + _ = src_ptr8[3..1]; +} +export fn fn119() void { + dest_end = 3; + _ = src_ptr8[3..dest_end]; +} +export fn fn120() void { + dest_end = 1; + _ = src_ptr8[3..dest_end]; +} +export fn fn121() void { + _ = src_ptr8[3..][0..2]; +} +export fn fn122() void { + _ = src_ptr8[3..][0..3]; +} +export fn fn123() void { + _ = src_ptr8[3..][0..1]; +} +export fn fn124() void { + dest_len = 3; + _ = src_ptr8[3..][0..dest_len]; +} +export fn fn125() void { + dest_len = 1; + _ = src_ptr8[3..][0..dest_len]; +} +var src_mem6: [2]u8 = undefined; +var src_ptr9: []u8 = src_mem6[0..2]; +export fn fn126() void { + _ = src_ptr9[3..2]; +} +export fn fn127() void { + _ = src_ptr9[3..1]; +} +var src_mem7: [3]u8 = undefined; +var src_ptr10: []u8 = src_mem7[0..3]; +export fn fn128() void { + _ = src_ptr10[3..2]; +} +export fn fn129() void { + _ = src_ptr10[3..1]; +} +var src_mem8: [1]u8 = undefined; +var src_ptr11: []u8 = src_mem8[0..1]; +export fn fn130() void { + _ = src_ptr11[3..2]; +} +export fn fn131() void { + _ = src_ptr11[3..1]; +} +const src_ptr12: [*]u8 = @ptrCast(&src_mem0); +export fn fn132() void { + _ = src_ptr12[0..3]; +} +export fn fn133() void { + _ = src_ptr12[0..][0..3]; +} +export fn fn134() void { + _ = src_ptr12[1..3]; +} +export fn fn135() void { + _ = src_ptr12[1..][0..2]; +} +export fn fn136() void { + _ = src_ptr12[1..][0..3]; +} +export fn fn137() void { + _ = src_ptr12[3..]; +} +export fn fn138() void { + _ = src_ptr12[3..2]; +} +export fn fn139() void { + _ = src_ptr12[3..3]; +} +export fn fn140() void { + _ = src_ptr12[3..1]; +} +export fn fn141() void { + dest_end = 3; + _ = src_ptr12[3..dest_end]; +} +export fn fn142() void { + dest_end = 1; + _ = src_ptr12[3..dest_end]; +} +export fn fn143() void { + _ = src_ptr12[3..][0..2]; +} +export fn fn144() void { + _ = src_ptr12[3..][0..3]; +} +export fn fn145() void { + _ = src_ptr12[3..][0..1]; +} +export fn fn146() void { + dest_len = 3; + _ = src_ptr12[3..][0..dest_len]; +} +export fn fn147() void { + dest_len = 1; + _ = src_ptr12[3..][0..dest_len]; +} +const src_ptr13: [*]u8 = @ptrCast(&src_mem1); +export fn fn148() void { + _ = src_ptr13[1..][0..3]; +} +export fn fn149() void { + _ = src_ptr13[3..2]; +} +export fn fn150() void { + _ = src_ptr13[3..1]; +} +export fn fn151() void { + _ = src_ptr13[3..][0..2]; +} +export fn fn152() void { + _ = src_ptr13[3..][0..3]; +} +export fn fn153() void { + _ = src_ptr13[3..][0..1]; +} +const src_ptr14: [*]u8 = @ptrCast(&src_mem2); +export fn fn154() void { + _ = src_ptr14[0..2]; +} +export fn fn155() void { + _ = src_ptr14[0..3]; +} +export fn fn156() void { + _ = src_ptr14[0..][0..2]; +} +export fn fn157() void { + _ = src_ptr14[0..][0..3]; +} +export fn fn158() void { + _ = src_ptr14[1..2]; +} +export fn fn159() void { + _ = src_ptr14[1..3]; +} +export fn fn160() void { + _ = src_ptr14[1..][0..2]; +} +export fn fn161() void { + _ = src_ptr14[1..][0..3]; +} +export fn fn162() void { + _ = src_ptr14[1..][0..1]; +} +export fn fn163() void { + _ = src_ptr14[3..]; +} +export fn fn164() void { + _ = src_ptr14[3..2]; +} +export fn fn165() void { + _ = src_ptr14[3..3]; +} +export fn fn166() void { + _ = src_ptr14[3..1]; +} +export fn fn167() void { + dest_end = 3; + _ = src_ptr14[3..dest_end]; +} +export fn fn168() void { + dest_end = 1; + _ = src_ptr14[3..dest_end]; +} +export fn fn169() void { + _ = src_ptr14[3..][0..2]; +} +export fn fn170() void { + _ = src_ptr14[3..][0..3]; +} +export fn fn171() void { + _ = src_ptr14[3..][0..1]; +} +export fn fn172() void { + dest_len = 3; + _ = src_ptr14[3..][0..dest_len]; +} +export fn fn173() void { + dest_len = 1; + _ = src_ptr14[3..][0..dest_len]; +} +var src_mem9: [2]u8 = undefined; +var src_ptr15: [*]u8 = @ptrCast(&src_mem9); +export fn fn174() void { + _ = src_ptr15[3..2]; +} +export fn fn175() void { + _ = src_ptr15[3..1]; +} +var src_mem10: [3]u8 = undefined; +var src_ptr16: [*]u8 = @ptrCast(&src_mem10); +export fn fn176() void { + _ = src_ptr16[3..2]; +} +export fn fn177() void { + _ = src_ptr16[3..1]; +} +var src_mem11: [1]u8 = undefined; +var src_ptr17: [*]u8 = @ptrCast(&src_mem11); +export fn fn178() void { + _ = src_ptr17[3..2]; +} +export fn fn179() void { + _ = src_ptr17[3..1]; +} +const nullptr: [*c]u8 = null; +const src_ptr18: [*c]u8 = nullptr; +export fn fn180() void { + _ = src_ptr18[0..]; +} +export fn fn181() void { + _ = src_ptr18[0..2]; +} +export fn fn182() void { + _ = src_ptr18[0..3]; +} +export fn fn183() void { + _ = src_ptr18[0..1]; +} +export fn fn184() void { + dest_end = 3; + _ = src_ptr18[0..dest_end]; +} +export fn fn185() void { + dest_end = 1; + _ = src_ptr18[0..dest_end]; +} +export fn fn186() void { + _ = src_ptr18[0..][0..2]; +} +export fn fn187() void { + _ = src_ptr18[0..][0..3]; +} +export fn fn188() void { + _ = src_ptr18[0..][0..1]; +} +export fn fn189() void { + dest_len = 3; + _ = src_ptr18[0..][0..dest_len]; +} +export fn fn190() void { + dest_len = 1; + _ = src_ptr18[0..][0..dest_len]; +} +export fn fn191() void { + _ = src_ptr18[1..]; +} +export fn fn192() void { + _ = src_ptr18[1..2]; +} +export fn fn193() void { + _ = src_ptr18[1..3]; +} +export fn fn194() void { + _ = src_ptr18[1..1]; +} +export fn fn195() void { + dest_end = 3; + _ = src_ptr18[1..dest_end]; +} +export fn fn196() void { + dest_end = 1; + _ = src_ptr18[1..dest_end]; +} +export fn fn197() void { + _ = src_ptr18[1..][0..2]; +} +export fn fn198() void { + _ = src_ptr18[1..][0..3]; +} +export fn fn199() void { + _ = src_ptr18[1..][0..1]; +} +export fn fn200() void { + dest_len = 3; + _ = src_ptr18[1..][0..dest_len]; +} +export fn fn201() void { + dest_len = 1; + _ = src_ptr18[1..][0..dest_len]; +} +export fn fn202() void { + _ = src_ptr18[3..]; +} +export fn fn203() void { + _ = src_ptr18[3..2]; +} +export fn fn204() void { + _ = src_ptr18[3..3]; +} +export fn fn205() void { + _ = src_ptr18[3..1]; +} +export fn fn206() void { + dest_end = 3; + _ = src_ptr18[3..dest_end]; +} +export fn fn207() void { + dest_end = 1; + _ = src_ptr18[3..dest_end]; +} +export fn fn208() void { + _ = src_ptr18[3..][0..2]; +} +export fn fn209() void { + _ = src_ptr18[3..][0..3]; +} +export fn fn210() void { + _ = src_ptr18[3..][0..1]; +} +export fn fn211() void { + dest_len = 3; + _ = src_ptr18[3..][0..dest_len]; +} +export fn fn212() void { + dest_len = 1; + _ = src_ptr18[3..][0..dest_len]; +} +const src_ptr19: [*c]u8 = nullptr; +export fn fn213() void { + _ = src_ptr19[0..]; +} +export fn fn214() void { + _ = src_ptr19[0..2]; +} +export fn fn215() void { + _ = src_ptr19[0..3]; +} +export fn fn216() void { + _ = src_ptr19[0..1]; +} +export fn fn217() void { + dest_end = 3; + _ = src_ptr19[0..dest_end]; +} +export fn fn218() void { + dest_end = 1; + _ = src_ptr19[0..dest_end]; +} +export fn fn219() void { + _ = src_ptr19[0..][0..2]; +} +export fn fn220() void { + _ = src_ptr19[0..][0..3]; +} +export fn fn221() void { + _ = src_ptr19[0..][0..1]; +} +export fn fn222() void { + dest_len = 3; + _ = src_ptr19[0..][0..dest_len]; +} +export fn fn223() void { + dest_len = 1; + _ = src_ptr19[0..][0..dest_len]; +} +export fn fn224() void { + _ = src_ptr19[1..]; +} +export fn fn225() void { + _ = src_ptr19[1..2]; +} +export fn fn226() void { + _ = src_ptr19[1..3]; +} +export fn fn227() void { + _ = src_ptr19[1..1]; +} +export fn fn228() void { + dest_end = 3; + _ = src_ptr19[1..dest_end]; +} +export fn fn229() void { + dest_end = 1; + _ = src_ptr19[1..dest_end]; +} +export fn fn230() void { + _ = src_ptr19[1..][0..2]; +} +export fn fn231() void { + _ = src_ptr19[1..][0..3]; +} +export fn fn232() void { + _ = src_ptr19[1..][0..1]; +} +export fn fn233() void { + dest_len = 3; + _ = src_ptr19[1..][0..dest_len]; +} +export fn fn234() void { + dest_len = 1; + _ = src_ptr19[1..][0..dest_len]; +} +export fn fn235() void { + _ = src_ptr19[3..]; +} +export fn fn236() void { + _ = src_ptr19[3..2]; +} +export fn fn237() void { + _ = src_ptr19[3..3]; +} +export fn fn238() void { + _ = src_ptr19[3..1]; +} +export fn fn239() void { + dest_end = 3; + _ = src_ptr19[3..dest_end]; +} +export fn fn240() void { + dest_end = 1; + _ = src_ptr19[3..dest_end]; +} +export fn fn241() void { + _ = src_ptr19[3..][0..2]; +} +export fn fn242() void { + _ = src_ptr19[3..][0..3]; +} +export fn fn243() void { + _ = src_ptr19[3..][0..1]; +} +export fn fn244() void { + dest_len = 3; + _ = src_ptr19[3..][0..dest_len]; +} +export fn fn245() void { + dest_len = 1; + _ = src_ptr19[3..][0..dest_len]; +} +const src_ptr20: [*c]u8 = nullptr; +export fn fn246() void { + _ = src_ptr20[0..]; +} +export fn fn247() void { + _ = src_ptr20[0..2]; +} +export fn fn248() void { + _ = src_ptr20[0..3]; +} +export fn fn249() void { + _ = src_ptr20[0..1]; +} +export fn fn250() void { + dest_end = 3; + _ = src_ptr20[0..dest_end]; +} +export fn fn251() void { + dest_end = 1; + _ = src_ptr20[0..dest_end]; +} +export fn fn252() void { + _ = src_ptr20[0..][0..2]; +} +export fn fn253() void { + _ = src_ptr20[0..][0..3]; +} +export fn fn254() void { + _ = src_ptr20[0..][0..1]; +} +export fn fn255() void { + dest_len = 3; + _ = src_ptr20[0..][0..dest_len]; +} +export fn fn256() void { + dest_len = 1; + _ = src_ptr20[0..][0..dest_len]; +} +export fn fn257() void { + _ = src_ptr20[1..]; +} +export fn fn258() void { + _ = src_ptr20[1..2]; +} +export fn fn259() void { + _ = src_ptr20[1..3]; +} +export fn fn260() void { + _ = src_ptr20[1..1]; +} +export fn fn261() void { + dest_end = 3; + _ = src_ptr20[1..dest_end]; +} +export fn fn262() void { + dest_end = 1; + _ = src_ptr20[1..dest_end]; +} +export fn fn263() void { + _ = src_ptr20[1..][0..2]; +} +export fn fn264() void { + _ = src_ptr20[1..][0..3]; +} +export fn fn265() void { + _ = src_ptr20[1..][0..1]; +} +export fn fn266() void { + dest_len = 3; + _ = src_ptr20[1..][0..dest_len]; +} +export fn fn267() void { + dest_len = 1; + _ = src_ptr20[1..][0..dest_len]; +} +export fn fn268() void { + _ = src_ptr20[3..]; +} +export fn fn269() void { + _ = src_ptr20[3..2]; +} +export fn fn270() void { + _ = src_ptr20[3..3]; +} +export fn fn271() void { + _ = src_ptr20[3..1]; +} +export fn fn272() void { + dest_end = 3; + _ = src_ptr20[3..dest_end]; +} +export fn fn273() void { + dest_end = 1; + _ = src_ptr20[3..dest_end]; +} +export fn fn274() void { + _ = src_ptr20[3..][0..2]; +} +export fn fn275() void { + _ = src_ptr20[3..][0..3]; +} +export fn fn276() void { + _ = src_ptr20[3..][0..1]; +} +export fn fn277() void { + dest_len = 3; + _ = src_ptr20[3..][0..dest_len]; +} +export fn fn278() void { + dest_len = 1; + _ = src_ptr20[3..][0..dest_len]; +} +var src_ptr21: [*c]u8 = null; +export fn fn279() void { + _ = src_ptr21[3..2]; +} +export fn fn280() void { + _ = src_ptr21[3..1]; +} +var src_ptr22: [*c]u8 = null; +export fn fn281() void { + _ = src_ptr22[3..2]; +} +export fn fn282() void { + _ = src_ptr22[3..1]; +} +var src_ptr23: [*c]u8 = null; +export fn fn283() void { + _ = src_ptr23[3..2]; +} +export fn fn284() void { + _ = src_ptr23[3..1]; +} +const src_ptr24: [*c]u8 = @ptrCast(&src_mem0); +export fn fn285() void { + _ = src_ptr24[0..3]; +} +export fn fn286() void { + _ = src_ptr24[0..][0..3]; +} +export fn fn287() void { + _ = src_ptr24[1..3]; +} +export fn fn288() void { + _ = src_ptr24[1..][0..2]; +} +export fn fn289() void { + _ = src_ptr24[1..][0..3]; +} +export fn fn290() void { + _ = src_ptr24[3..]; +} +export fn fn291() void { + _ = src_ptr24[3..2]; +} +export fn fn292() void { + _ = src_ptr24[3..3]; +} +export fn fn293() void { + _ = src_ptr24[3..1]; +} +export fn fn294() void { + dest_end = 3; + _ = src_ptr24[3..dest_end]; +} +export fn fn295() void { + dest_end = 1; + _ = src_ptr24[3..dest_end]; +} +export fn fn296() void { + _ = src_ptr24[3..][0..2]; +} +export fn fn297() void { + _ = src_ptr24[3..][0..3]; +} +export fn fn298() void { + _ = src_ptr24[3..][0..1]; +} +export fn fn299() void { + dest_len = 3; + _ = src_ptr24[3..][0..dest_len]; +} +export fn fn300() void { + dest_len = 1; + _ = src_ptr24[3..][0..dest_len]; +} +const src_ptr25: [*c]u8 = @ptrCast(&src_mem1); +export fn fn301() void { + _ = src_ptr25[1..][0..3]; +} +export fn fn302() void { + _ = src_ptr25[3..2]; +} +export fn fn303() void { + _ = src_ptr25[3..1]; +} +export fn fn304() void { + _ = src_ptr25[3..][0..2]; +} +export fn fn305() void { + _ = src_ptr25[3..][0..3]; +} +export fn fn306() void { + _ = src_ptr25[3..][0..1]; +} +const src_ptr26: [*c]u8 = @ptrCast(&src_mem2); +export fn fn307() void { + _ = src_ptr26[0..2]; +} +export fn fn308() void { + _ = src_ptr26[0..3]; +} +export fn fn309() void { + _ = src_ptr26[0..][0..2]; +} +export fn fn310() void { + _ = src_ptr26[0..][0..3]; +} +export fn fn311() void { + _ = src_ptr26[1..2]; +} +export fn fn312() void { + _ = src_ptr26[1..3]; +} +export fn fn313() void { + _ = src_ptr26[1..][0..2]; +} +export fn fn314() void { + _ = src_ptr26[1..][0..3]; +} +export fn fn315() void { + _ = src_ptr26[1..][0..1]; +} +export fn fn316() void { + _ = src_ptr26[3..]; +} +export fn fn317() void { + _ = src_ptr26[3..2]; +} +export fn fn318() void { + _ = src_ptr26[3..3]; +} +export fn fn319() void { + _ = src_ptr26[3..1]; +} +export fn fn320() void { + dest_end = 3; + _ = src_ptr26[3..dest_end]; +} +export fn fn321() void { + dest_end = 1; + _ = src_ptr26[3..dest_end]; +} +export fn fn322() void { + _ = src_ptr26[3..][0..2]; +} +export fn fn323() void { + _ = src_ptr26[3..][0..3]; +} +export fn fn324() void { + _ = src_ptr26[3..][0..1]; +} +export fn fn325() void { + dest_len = 3; + _ = src_ptr26[3..][0..dest_len]; +} +export fn fn326() void { + dest_len = 1; + _ = src_ptr26[3..][0..dest_len]; +} +var src_mem12: [2]u8 = undefined; +var src_ptr27: [*c]u8 = @ptrCast(&src_mem12); +export fn fn327() void { + _ = src_ptr27[3..2]; +} +export fn fn328() void { + _ = src_ptr27[3..1]; +} +var src_mem13: [3]u8 = undefined; +var src_ptr28: [*c]u8 = @ptrCast(&src_mem13); +export fn fn329() void { + _ = src_ptr28[3..2]; +} +export fn fn330() void { + _ = src_ptr28[3..1]; +} +var src_mem14: [1]u8 = undefined; +var src_ptr29: [*c]u8 = @ptrCast(&src_mem14); +export fn fn331() void { + _ = src_ptr29[3..2]; +} +export fn fn332() void { + _ = src_ptr29[3..1]; +} +var src_mem15: [2]u8 = .{ 0, 0 }; +const src_ptr30: *[2]u8 = src_mem15[0..2]; +export fn fn333() void { + _ = src_ptr30[0..3]; +} +export fn fn334() void { + _ = src_ptr30[0..][0..3]; +} +export fn fn335() void { + _ = src_ptr30[1..3]; +} +export fn fn336() void { + _ = src_ptr30[1..][0..2]; +} +export fn fn337() void { + _ = src_ptr30[1..][0..3]; +} +export fn fn338() void { + _ = src_ptr30[3..]; +} +export fn fn339() void { + _ = src_ptr30[3..2]; +} +export fn fn340() void { + _ = src_ptr30[3..3]; +} +export fn fn341() void { + _ = src_ptr30[3..1]; +} +export fn fn342() void { + dest_end = 3; + _ = src_ptr30[3..dest_end]; +} +export fn fn343() void { + dest_end = 1; + _ = src_ptr30[3..dest_end]; +} +export fn fn344() void { + _ = src_ptr30[3..][0..2]; +} +export fn fn345() void { + _ = src_ptr30[3..][0..3]; +} +export fn fn346() void { + _ = src_ptr30[3..][0..1]; +} +export fn fn347() void { + dest_len = 3; + _ = src_ptr30[3..][0..dest_len]; +} +export fn fn348() void { + dest_len = 1; + _ = src_ptr30[3..][0..dest_len]; +} +export fn fn349() void { + _ = src_ptr30[0.. :1]; +} +export fn fn350() void { + _ = src_ptr30[0..2 :1]; +} +export fn fn351() void { + _ = src_ptr30[0..3 :1]; +} +export fn fn352() void { + _ = src_ptr30[0..][0..2 :1]; +} +export fn fn353() void { + _ = src_ptr30[0..][0..3 :1]; +} +export fn fn354() void { + _ = src_ptr30[1.. :1]; +} +export fn fn355() void { + _ = src_ptr30[1..2 :1]; +} +export fn fn356() void { + _ = src_ptr30[1..3 :1]; +} +export fn fn357() void { + _ = src_ptr30[1..][0..2 :1]; +} +export fn fn358() void { + _ = src_ptr30[1..][0..3 :1]; +} +export fn fn359() void { + _ = src_ptr30[1..][0..1 :1]; +} +export fn fn360() void { + _ = src_ptr30[3.. :1]; +} +export fn fn361() void { + _ = src_ptr30[3..2 :1]; +} +export fn fn362() void { + _ = src_ptr30[3..3 :1]; +} +export fn fn363() void { + _ = src_ptr30[3..1 :1]; +} +export fn fn364() void { + dest_end = 3; + _ = src_ptr30[3..dest_end :1]; +} +export fn fn365() void { + dest_end = 1; + _ = src_ptr30[3..dest_end :1]; +} +export fn fn366() void { + _ = src_ptr30[3..][0..2 :1]; +} +export fn fn367() void { + _ = src_ptr30[3..][0..3 :1]; +} +export fn fn368() void { + _ = src_ptr30[3..][0..1 :1]; +} +export fn fn369() void { + dest_len = 3; + _ = src_ptr30[3..][0..dest_len :1]; +} +export fn fn370() void { + dest_len = 1; + _ = src_ptr30[3..][0..dest_len :1]; +} +var src_mem16: [2]u8 = .{ 0, 0 }; +const src_ptr31: *[1:0]u8 = src_mem16[0..1 :0]; +export fn fn371() void { + _ = src_ptr31[0..3]; +} +export fn fn372() void { + _ = src_ptr31[0..][0..3]; +} +export fn fn373() void { + _ = src_ptr31[1..3]; +} +export fn fn374() void { + _ = src_ptr31[1..][0..2]; +} +export fn fn375() void { + _ = src_ptr31[1..][0..3]; +} +export fn fn376() void { + _ = src_ptr31[3..]; +} +export fn fn377() void { + _ = src_ptr31[3..2]; +} +export fn fn378() void { + _ = src_ptr31[3..3]; +} +export fn fn379() void { + _ = src_ptr31[3..1]; +} +export fn fn380() void { + dest_end = 3; + _ = src_ptr31[3..dest_end]; +} +export fn fn381() void { + dest_end = 1; + _ = src_ptr31[3..dest_end]; +} +export fn fn382() void { + _ = src_ptr31[3..][0..2]; +} +export fn fn383() void { + _ = src_ptr31[3..][0..3]; +} +export fn fn384() void { + _ = src_ptr31[3..][0..1]; +} +export fn fn385() void { + dest_len = 3; + _ = src_ptr31[3..][0..dest_len]; +} +export fn fn386() void { + dest_len = 1; + _ = src_ptr31[3..][0..dest_len]; +} +export fn fn387() void { + _ = src_ptr31[0..2 :1]; +} +export fn fn388() void { + _ = src_ptr31[0..3 :1]; +} +export fn fn389() void { + _ = src_ptr31[0..][0..2 :1]; +} +export fn fn390() void { + _ = src_ptr31[0..][0..3 :1]; +} +export fn fn391() void { + _ = src_ptr31[1..2 :1]; +} +export fn fn392() void { + _ = src_ptr31[1..3 :1]; +} +export fn fn393() void { + _ = src_ptr31[1..][0..2 :1]; +} +export fn fn394() void { + _ = src_ptr31[1..][0..3 :1]; +} +export fn fn395() void { + _ = src_ptr31[1..][0..1 :1]; +} +export fn fn396() void { + _ = src_ptr31[3.. :1]; +} +export fn fn397() void { + _ = src_ptr31[3..2 :1]; +} +export fn fn398() void { + _ = src_ptr31[3..3 :1]; +} +export fn fn399() void { + _ = src_ptr31[3..1 :1]; +} +export fn fn400() void { + dest_end = 3; + _ = src_ptr31[3..dest_end :1]; +} +export fn fn401() void { + dest_end = 1; + _ = src_ptr31[3..dest_end :1]; +} +export fn fn402() void { + _ = src_ptr31[3..][0..2 :1]; +} +export fn fn403() void { + _ = src_ptr31[3..][0..3 :1]; +} +export fn fn404() void { + _ = src_ptr31[3..][0..1 :1]; +} +export fn fn405() void { + dest_len = 3; + _ = src_ptr31[3..][0..dest_len :1]; +} +export fn fn406() void { + dest_len = 1; + _ = src_ptr31[3..][0..dest_len :1]; +} +var src_mem17: [3]u8 = .{ 0, 0, 0 }; +const src_ptr32: *[3]u8 = src_mem17[0..3]; +export fn fn407() void { + _ = src_ptr32[1..][0..3]; +} +export fn fn408() void { + _ = src_ptr32[3..2]; +} +export fn fn409() void { + _ = src_ptr32[3..1]; +} +export fn fn410() void { + _ = src_ptr32[3..][0..2]; +} +export fn fn411() void { + _ = src_ptr32[3..][0..3]; +} +export fn fn412() void { + _ = src_ptr32[3..][0..1]; +} +export fn fn413() void { + _ = src_ptr32[0.. :1]; +} +export fn fn414() void { + _ = src_ptr32[0..3 :1]; +} +export fn fn415() void { + _ = src_ptr32[0..][0..3 :1]; +} +export fn fn416() void { + _ = src_ptr32[1.. :1]; +} +export fn fn417() void { + _ = src_ptr32[1..3 :1]; +} +export fn fn418() void { + _ = src_ptr32[1..][0..2 :1]; +} +export fn fn419() void { + _ = src_ptr32[1..][0..3 :1]; +} +export fn fn420() void { + _ = src_ptr32[3.. :1]; +} +export fn fn421() void { + _ = src_ptr32[3..2 :1]; +} +export fn fn422() void { + _ = src_ptr32[3..3 :1]; +} +export fn fn423() void { + _ = src_ptr32[3..1 :1]; +} +export fn fn424() void { + dest_end = 3; + _ = src_ptr32[3..dest_end :1]; +} +export fn fn425() void { + dest_end = 1; + _ = src_ptr32[3..dest_end :1]; +} +export fn fn426() void { + _ = src_ptr32[3..][0..2 :1]; +} +export fn fn427() void { + _ = src_ptr32[3..][0..3 :1]; +} +export fn fn428() void { + _ = src_ptr32[3..][0..1 :1]; +} +export fn fn429() void { + dest_len = 3; + _ = src_ptr32[3..][0..dest_len :1]; +} +export fn fn430() void { + dest_len = 1; + _ = src_ptr32[3..][0..dest_len :1]; +} +var src_mem18: [3]u8 = .{ 0, 0, 0 }; +const src_ptr33: *[2:0]u8 = src_mem18[0..2 :0]; +export fn fn431() void { + _ = src_ptr33[1..][0..3]; +} +export fn fn432() void { + _ = src_ptr33[3..]; +} +export fn fn433() void { + _ = src_ptr33[3..2]; +} +export fn fn434() void { + _ = src_ptr33[3..1]; +} +export fn fn435() void { + _ = src_ptr33[3..][0..2]; +} +export fn fn436() void { + _ = src_ptr33[3..][0..3]; +} +export fn fn437() void { + _ = src_ptr33[3..][0..1]; +} +export fn fn438() void { + _ = src_ptr33[0..3 :1]; +} +export fn fn439() void { + _ = src_ptr33[0..][0..3 :1]; +} +export fn fn440() void { + _ = src_ptr33[1..3 :1]; +} +export fn fn441() void { + _ = src_ptr33[1..][0..2 :1]; +} +export fn fn442() void { + _ = src_ptr33[1..][0..3 :1]; +} +export fn fn443() void { + _ = src_ptr33[3.. :1]; +} +export fn fn444() void { + _ = src_ptr33[3..2 :1]; +} +export fn fn445() void { + _ = src_ptr33[3..3 :1]; +} +export fn fn446() void { + _ = src_ptr33[3..1 :1]; +} +export fn fn447() void { + dest_end = 3; + _ = src_ptr33[3..dest_end :1]; +} +export fn fn448() void { + dest_end = 1; + _ = src_ptr33[3..dest_end :1]; +} +export fn fn449() void { + _ = src_ptr33[3..][0..2 :1]; +} +export fn fn450() void { + _ = src_ptr33[3..][0..3 :1]; +} +export fn fn451() void { + _ = src_ptr33[3..][0..1 :1]; +} +export fn fn452() void { + dest_len = 3; + _ = src_ptr33[3..][0..dest_len :1]; +} +export fn fn453() void { + dest_len = 1; + _ = src_ptr33[3..][0..dest_len :1]; +} +var src_mem19: [1]u8 = .{0}; +const src_ptr34: *[1]u8 = src_mem19[0..1]; +export fn fn454() void { + _ = src_ptr34[0..2]; +} +export fn fn455() void { + _ = src_ptr34[0..3]; +} +export fn fn456() void { + _ = src_ptr34[0..][0..2]; +} +export fn fn457() void { + _ = src_ptr34[0..][0..3]; +} +export fn fn458() void { + _ = src_ptr34[1..2]; +} +export fn fn459() void { + _ = src_ptr34[1..3]; +} +export fn fn460() void { + _ = src_ptr34[1..][0..2]; +} +export fn fn461() void { + _ = src_ptr34[1..][0..3]; +} +export fn fn462() void { + _ = src_ptr34[1..][0..1]; +} +export fn fn463() void { + _ = src_ptr34[3..]; +} +export fn fn464() void { + _ = src_ptr34[3..2]; +} +export fn fn465() void { + _ = src_ptr34[3..3]; +} +export fn fn466() void { + _ = src_ptr34[3..1]; +} +export fn fn467() void { + dest_end = 3; + _ = src_ptr34[3..dest_end]; +} +export fn fn468() void { + dest_end = 1; + _ = src_ptr34[3..dest_end]; +} +export fn fn469() void { + _ = src_ptr34[3..][0..2]; +} +export fn fn470() void { + _ = src_ptr34[3..][0..3]; +} +export fn fn471() void { + _ = src_ptr34[3..][0..1]; +} +export fn fn472() void { + dest_len = 3; + _ = src_ptr34[3..][0..dest_len]; +} +export fn fn473() void { + dest_len = 1; + _ = src_ptr34[3..][0..dest_len]; +} +export fn fn474() void { + _ = src_ptr34[0.. :1]; +} +export fn fn475() void { + _ = src_ptr34[0..2 :1]; +} +export fn fn476() void { + _ = src_ptr34[0..3 :1]; +} +export fn fn477() void { + _ = src_ptr34[0..1 :1]; +} +export fn fn478() void { + _ = src_ptr34[0..][0..2 :1]; +} +export fn fn479() void { + _ = src_ptr34[0..][0..3 :1]; +} +export fn fn480() void { + _ = src_ptr34[0..][0..1 :1]; +} +export fn fn481() void { + _ = src_ptr34[1.. :1]; +} +export fn fn482() void { + _ = src_ptr34[1..2 :1]; +} +export fn fn483() void { + _ = src_ptr34[1..3 :1]; +} +export fn fn484() void { + _ = src_ptr34[1..1 :1]; +} +export fn fn485() void { + dest_end = 3; + _ = src_ptr34[1..dest_end :1]; +} +export fn fn486() void { + dest_end = 1; + _ = src_ptr34[1..dest_end :1]; +} +export fn fn487() void { + _ = src_ptr34[1..][0..2 :1]; +} +export fn fn488() void { + _ = src_ptr34[1..][0..3 :1]; +} +export fn fn489() void { + _ = src_ptr34[1..][0..1 :1]; +} +export fn fn490() void { + dest_len = 3; + _ = src_ptr34[1..][0..dest_len :1]; +} +export fn fn491() void { + dest_len = 1; + _ = src_ptr34[1..][0..dest_len :1]; +} +export fn fn492() void { + _ = src_ptr34[3.. :1]; +} +export fn fn493() void { + _ = src_ptr34[3..2 :1]; +} +export fn fn494() void { + _ = src_ptr34[3..3 :1]; +} +export fn fn495() void { + _ = src_ptr34[3..1 :1]; +} +export fn fn496() void { + dest_end = 3; + _ = src_ptr34[3..dest_end :1]; +} +export fn fn497() void { + dest_end = 1; + _ = src_ptr34[3..dest_end :1]; +} +export fn fn498() void { + _ = src_ptr34[3..][0..2 :1]; +} +export fn fn499() void { + _ = src_ptr34[3..][0..3 :1]; +} +export fn fn500() void { + _ = src_ptr34[3..][0..1 :1]; +} +export fn fn501() void { + dest_len = 3; + _ = src_ptr34[3..][0..dest_len :1]; +} +export fn fn502() void { + dest_len = 1; + _ = src_ptr34[3..][0..dest_len :1]; +} +var src_mem20: [1]u8 = .{0}; +const src_ptr35: *[0:0]u8 = src_mem20[0..0 :0]; +export fn fn503() void { + _ = src_ptr35[0..2]; +} +export fn fn504() void { + _ = src_ptr35[0..3]; +} +export fn fn505() void { + _ = src_ptr35[0..][0..2]; +} +export fn fn506() void { + _ = src_ptr35[0..][0..3]; +} +export fn fn507() void { + _ = src_ptr35[1..]; +} +export fn fn508() void { + _ = src_ptr35[1..2]; +} +export fn fn509() void { + _ = src_ptr35[1..3]; +} +export fn fn510() void { + _ = src_ptr35[1..][0..2]; +} +export fn fn511() void { + _ = src_ptr35[1..][0..3]; +} +export fn fn512() void { + _ = src_ptr35[1..][0..1]; +} +export fn fn513() void { + _ = src_ptr35[3..]; +} +export fn fn514() void { + _ = src_ptr35[3..2]; +} +export fn fn515() void { + _ = src_ptr35[3..3]; +} +export fn fn516() void { + _ = src_ptr35[3..1]; +} +export fn fn517() void { + dest_end = 3; + _ = src_ptr35[3..dest_end]; +} +export fn fn518() void { + dest_end = 1; + _ = src_ptr35[3..dest_end]; +} +export fn fn519() void { + _ = src_ptr35[3..][0..2]; +} +export fn fn520() void { + _ = src_ptr35[3..][0..3]; +} +export fn fn521() void { + _ = src_ptr35[3..][0..1]; +} +export fn fn522() void { + dest_len = 3; + _ = src_ptr35[3..][0..dest_len]; +} +export fn fn523() void { + dest_len = 1; + _ = src_ptr35[3..][0..dest_len]; +} +export fn fn524() void { + _ = src_ptr35[0..2 :1]; +} +export fn fn525() void { + _ = src_ptr35[0..3 :1]; +} +export fn fn526() void { + _ = src_ptr35[0..1 :1]; +} +export fn fn527() void { + _ = src_ptr35[0..][0..2 :1]; +} +export fn fn528() void { + _ = src_ptr35[0..][0..3 :1]; +} +export fn fn529() void { + _ = src_ptr35[0..][0..1 :1]; +} +export fn fn530() void { + _ = src_ptr35[1.. :1]; +} +export fn fn531() void { + _ = src_ptr35[1..2 :1]; +} +export fn fn532() void { + _ = src_ptr35[1..3 :1]; +} +export fn fn533() void { + _ = src_ptr35[1..1 :1]; +} +export fn fn534() void { + dest_end = 3; + _ = src_ptr35[1..dest_end :1]; +} +export fn fn535() void { + dest_end = 1; + _ = src_ptr35[1..dest_end :1]; +} +export fn fn536() void { + _ = src_ptr35[1..][0..2 :1]; +} +export fn fn537() void { + _ = src_ptr35[1..][0..3 :1]; +} +export fn fn538() void { + _ = src_ptr35[1..][0..1 :1]; +} +export fn fn539() void { + dest_len = 3; + _ = src_ptr35[1..][0..dest_len :1]; +} +export fn fn540() void { + dest_len = 1; + _ = src_ptr35[1..][0..dest_len :1]; +} +export fn fn541() void { + _ = src_ptr35[3.. :1]; +} +export fn fn542() void { + _ = src_ptr35[3..2 :1]; +} +export fn fn543() void { + _ = src_ptr35[3..3 :1]; +} +export fn fn544() void { + _ = src_ptr35[3..1 :1]; +} +export fn fn545() void { + dest_end = 3; + _ = src_ptr35[3..dest_end :1]; +} +export fn fn546() void { + dest_end = 1; + _ = src_ptr35[3..dest_end :1]; +} +export fn fn547() void { + _ = src_ptr35[3..][0..2 :1]; +} +export fn fn548() void { + _ = src_ptr35[3..][0..3 :1]; +} +export fn fn549() void { + _ = src_ptr35[3..][0..1 :1]; +} +export fn fn550() void { + dest_len = 3; + _ = src_ptr35[3..][0..dest_len :1]; +} +export fn fn551() void { + dest_len = 1; + _ = src_ptr35[3..][0..dest_len :1]; +} +var src_mem21: [2]u8 = .{ 0, 0 }; +var src_ptr36: *[2]u8 = src_mem21[0..2]; +export fn fn552() void { + _ = src_ptr36[0..3]; +} +export fn fn553() void { + _ = src_ptr36[0..][0..3]; +} +export fn fn554() void { + _ = src_ptr36[1..3]; +} +export fn fn555() void { + _ = src_ptr36[1..][0..2]; +} +export fn fn556() void { + _ = src_ptr36[1..][0..3]; +} +export fn fn557() void { + _ = src_ptr36[3..]; +} +export fn fn558() void { + _ = src_ptr36[3..2]; +} +export fn fn559() void { + _ = src_ptr36[3..3]; +} +export fn fn560() void { + _ = src_ptr36[3..1]; +} +export fn fn561() void { + dest_end = 3; + _ = src_ptr36[3..dest_end]; +} +export fn fn562() void { + dest_end = 1; + _ = src_ptr36[3..dest_end]; +} +export fn fn563() void { + _ = src_ptr36[3..][0..2]; +} +export fn fn564() void { + _ = src_ptr36[3..][0..3]; +} +export fn fn565() void { + _ = src_ptr36[3..][0..1]; +} +export fn fn566() void { + dest_len = 3; + _ = src_ptr36[3..][0..dest_len]; +} +export fn fn567() void { + dest_len = 1; + _ = src_ptr36[3..][0..dest_len]; +} +export fn fn568() void { + _ = src_ptr36[0.. :1]; +} +export fn fn569() void { + _ = src_ptr36[0..2 :1]; +} +export fn fn570() void { + _ = src_ptr36[0..3 :1]; +} +export fn fn571() void { + _ = src_ptr36[0..][0..2 :1]; +} +export fn fn572() void { + _ = src_ptr36[0..][0..3 :1]; +} +export fn fn573() void { + _ = src_ptr36[1.. :1]; +} +export fn fn574() void { + _ = src_ptr36[1..2 :1]; +} +export fn fn575() void { + _ = src_ptr36[1..3 :1]; +} +export fn fn576() void { + _ = src_ptr36[1..][0..2 :1]; +} +export fn fn577() void { + _ = src_ptr36[1..][0..3 :1]; +} +export fn fn578() void { + _ = src_ptr36[1..][0..1 :1]; +} +export fn fn579() void { + _ = src_ptr36[3.. :1]; +} +export fn fn580() void { + _ = src_ptr36[3..2 :1]; +} +export fn fn581() void { + _ = src_ptr36[3..3 :1]; +} +export fn fn582() void { + _ = src_ptr36[3..1 :1]; +} +export fn fn583() void { + dest_end = 3; + _ = src_ptr36[3..dest_end :1]; +} +export fn fn584() void { + dest_end = 1; + _ = src_ptr36[3..dest_end :1]; +} +export fn fn585() void { + _ = src_ptr36[3..][0..2 :1]; +} +export fn fn586() void { + _ = src_ptr36[3..][0..3 :1]; +} +export fn fn587() void { + _ = src_ptr36[3..][0..1 :1]; +} +export fn fn588() void { + dest_len = 3; + _ = src_ptr36[3..][0..dest_len :1]; +} +export fn fn589() void { + dest_len = 1; + _ = src_ptr36[3..][0..dest_len :1]; +} +var src_mem22: [2]u8 = .{ 0, 0 }; +var src_ptr37: *[1:0]u8 = src_mem22[0..1 :0]; +export fn fn590() void { + _ = src_ptr37[0..3]; +} +export fn fn591() void { + _ = src_ptr37[0..][0..3]; +} +export fn fn592() void { + _ = src_ptr37[1..3]; +} +export fn fn593() void { + _ = src_ptr37[1..][0..2]; +} +export fn fn594() void { + _ = src_ptr37[1..][0..3]; +} +export fn fn595() void { + _ = src_ptr37[3..]; +} +export fn fn596() void { + _ = src_ptr37[3..2]; +} +export fn fn597() void { + _ = src_ptr37[3..3]; +} +export fn fn598() void { + _ = src_ptr37[3..1]; +} +export fn fn599() void { + dest_end = 3; + _ = src_ptr37[3..dest_end]; +} +export fn fn600() void { + dest_end = 1; + _ = src_ptr37[3..dest_end]; +} +export fn fn601() void { + _ = src_ptr37[3..][0..2]; +} +export fn fn602() void { + _ = src_ptr37[3..][0..3]; +} +export fn fn603() void { + _ = src_ptr37[3..][0..1]; +} +export fn fn604() void { + dest_len = 3; + _ = src_ptr37[3..][0..dest_len]; +} +export fn fn605() void { + dest_len = 1; + _ = src_ptr37[3..][0..dest_len]; +} +export fn fn606() void { + _ = src_ptr37[0..2 :1]; +} +export fn fn607() void { + _ = src_ptr37[0..3 :1]; +} +export fn fn608() void { + _ = src_ptr37[0..][0..2 :1]; +} +export fn fn609() void { + _ = src_ptr37[0..][0..3 :1]; +} +export fn fn610() void { + _ = src_ptr37[1..2 :1]; +} +export fn fn611() void { + _ = src_ptr37[1..3 :1]; +} +export fn fn612() void { + _ = src_ptr37[1..][0..2 :1]; +} +export fn fn613() void { + _ = src_ptr37[1..][0..3 :1]; +} +export fn fn614() void { + _ = src_ptr37[1..][0..1 :1]; +} +export fn fn615() void { + _ = src_ptr37[3.. :1]; +} +export fn fn616() void { + _ = src_ptr37[3..2 :1]; +} +export fn fn617() void { + _ = src_ptr37[3..3 :1]; +} +export fn fn618() void { + _ = src_ptr37[3..1 :1]; +} +export fn fn619() void { + dest_end = 3; + _ = src_ptr37[3..dest_end :1]; +} +export fn fn620() void { + dest_end = 1; + _ = src_ptr37[3..dest_end :1]; +} +export fn fn621() void { + _ = src_ptr37[3..][0..2 :1]; +} +export fn fn622() void { + _ = src_ptr37[3..][0..3 :1]; +} +export fn fn623() void { + _ = src_ptr37[3..][0..1 :1]; +} +export fn fn624() void { + dest_len = 3; + _ = src_ptr37[3..][0..dest_len :1]; +} +export fn fn625() void { + dest_len = 1; + _ = src_ptr37[3..][0..dest_len :1]; +} +var src_mem23: [3]u8 = .{ 0, 0, 0 }; +var src_ptr38: *[3]u8 = src_mem23[0..3]; +export fn fn626() void { + _ = src_ptr38[1..][0..3]; +} +export fn fn627() void { + _ = src_ptr38[3..2]; +} +export fn fn628() void { + _ = src_ptr38[3..1]; +} +export fn fn629() void { + _ = src_ptr38[3..][0..2]; +} +export fn fn630() void { + _ = src_ptr38[3..][0..3]; +} +export fn fn631() void { + _ = src_ptr38[3..][0..1]; +} +export fn fn632() void { + _ = src_ptr38[0.. :1]; +} +export fn fn633() void { + _ = src_ptr38[0..3 :1]; +} +export fn fn634() void { + _ = src_ptr38[0..][0..3 :1]; +} +export fn fn635() void { + _ = src_ptr38[1.. :1]; +} +export fn fn636() void { + _ = src_ptr38[1..3 :1]; +} +export fn fn637() void { + _ = src_ptr38[1..][0..2 :1]; +} +export fn fn638() void { + _ = src_ptr38[1..][0..3 :1]; +} +export fn fn639() void { + _ = src_ptr38[3.. :1]; +} +export fn fn640() void { + _ = src_ptr38[3..2 :1]; +} +export fn fn641() void { + _ = src_ptr38[3..3 :1]; +} +export fn fn642() void { + _ = src_ptr38[3..1 :1]; +} +export fn fn643() void { + dest_end = 3; + _ = src_ptr38[3..dest_end :1]; +} +export fn fn644() void { + dest_end = 1; + _ = src_ptr38[3..dest_end :1]; +} +export fn fn645() void { + _ = src_ptr38[3..][0..2 :1]; +} +export fn fn646() void { + _ = src_ptr38[3..][0..3 :1]; +} +export fn fn647() void { + _ = src_ptr38[3..][0..1 :1]; +} +export fn fn648() void { + dest_len = 3; + _ = src_ptr38[3..][0..dest_len :1]; +} +export fn fn649() void { + dest_len = 1; + _ = src_ptr38[3..][0..dest_len :1]; +} +var src_mem24: [3]u8 = .{ 0, 0, 0 }; +var src_ptr39: *[2:0]u8 = src_mem24[0..2 :0]; +export fn fn650() void { + _ = src_ptr39[1..][0..3]; +} +export fn fn651() void { + _ = src_ptr39[3..]; +} +export fn fn652() void { + _ = src_ptr39[3..2]; +} +export fn fn653() void { + _ = src_ptr39[3..1]; +} +export fn fn654() void { + _ = src_ptr39[3..][0..2]; +} +export fn fn655() void { + _ = src_ptr39[3..][0..3]; +} +export fn fn656() void { + _ = src_ptr39[3..][0..1]; +} +export fn fn657() void { + _ = src_ptr39[0..3 :1]; +} +export fn fn658() void { + _ = src_ptr39[0..][0..3 :1]; +} +export fn fn659() void { + _ = src_ptr39[1..3 :1]; +} +export fn fn660() void { + _ = src_ptr39[1..][0..2 :1]; +} +export fn fn661() void { + _ = src_ptr39[1..][0..3 :1]; +} +export fn fn662() void { + _ = src_ptr39[3.. :1]; +} +export fn fn663() void { + _ = src_ptr39[3..2 :1]; +} +export fn fn664() void { + _ = src_ptr39[3..3 :1]; +} +export fn fn665() void { + _ = src_ptr39[3..1 :1]; +} +export fn fn666() void { + dest_end = 3; + _ = src_ptr39[3..dest_end :1]; +} +export fn fn667() void { + dest_end = 1; + _ = src_ptr39[3..dest_end :1]; +} +export fn fn668() void { + _ = src_ptr39[3..][0..2 :1]; +} +export fn fn669() void { + _ = src_ptr39[3..][0..3 :1]; +} +export fn fn670() void { + _ = src_ptr39[3..][0..1 :1]; +} +export fn fn671() void { + dest_len = 3; + _ = src_ptr39[3..][0..dest_len :1]; +} +export fn fn672() void { + dest_len = 1; + _ = src_ptr39[3..][0..dest_len :1]; +} +var src_mem25: [1]u8 = .{0}; +var src_ptr40: *[1]u8 = src_mem25[0..1]; +export fn fn673() void { + _ = src_ptr40[0..2]; +} +export fn fn674() void { + _ = src_ptr40[0..3]; +} +export fn fn675() void { + _ = src_ptr40[0..][0..2]; +} +export fn fn676() void { + _ = src_ptr40[0..][0..3]; +} +export fn fn677() void { + _ = src_ptr40[1..2]; +} +export fn fn678() void { + _ = src_ptr40[1..3]; +} +export fn fn679() void { + _ = src_ptr40[1..][0..2]; +} +export fn fn680() void { + _ = src_ptr40[1..][0..3]; +} +export fn fn681() void { + _ = src_ptr40[1..][0..1]; +} +export fn fn682() void { + _ = src_ptr40[3..]; +} +export fn fn683() void { + _ = src_ptr40[3..2]; +} +export fn fn684() void { + _ = src_ptr40[3..3]; +} +export fn fn685() void { + _ = src_ptr40[3..1]; +} +export fn fn686() void { + dest_end = 3; + _ = src_ptr40[3..dest_end]; +} +export fn fn687() void { + dest_end = 1; + _ = src_ptr40[3..dest_end]; +} +export fn fn688() void { + _ = src_ptr40[3..][0..2]; +} +export fn fn689() void { + _ = src_ptr40[3..][0..3]; +} +export fn fn690() void { + _ = src_ptr40[3..][0..1]; +} +export fn fn691() void { + dest_len = 3; + _ = src_ptr40[3..][0..dest_len]; +} +export fn fn692() void { + dest_len = 1; + _ = src_ptr40[3..][0..dest_len]; +} +export fn fn693() void { + _ = src_ptr40[0.. :1]; +} +export fn fn694() void { + _ = src_ptr40[0..2 :1]; +} +export fn fn695() void { + _ = src_ptr40[0..3 :1]; +} +export fn fn696() void { + _ = src_ptr40[0..1 :1]; +} +export fn fn697() void { + _ = src_ptr40[0..][0..2 :1]; +} +export fn fn698() void { + _ = src_ptr40[0..][0..3 :1]; +} +export fn fn699() void { + _ = src_ptr40[0..][0..1 :1]; +} +export fn fn700() void { + _ = src_ptr40[1.. :1]; +} +export fn fn701() void { + _ = src_ptr40[1..2 :1]; +} +export fn fn702() void { + _ = src_ptr40[1..3 :1]; +} +export fn fn703() void { + _ = src_ptr40[1..1 :1]; +} +export fn fn704() void { + dest_end = 3; + _ = src_ptr40[1..dest_end :1]; +} +export fn fn705() void { + dest_end = 1; + _ = src_ptr40[1..dest_end :1]; +} +export fn fn706() void { + _ = src_ptr40[1..][0..2 :1]; +} +export fn fn707() void { + _ = src_ptr40[1..][0..3 :1]; +} +export fn fn708() void { + _ = src_ptr40[1..][0..1 :1]; +} +export fn fn709() void { + dest_len = 3; + _ = src_ptr40[1..][0..dest_len :1]; +} +export fn fn710() void { + dest_len = 1; + _ = src_ptr40[1..][0..dest_len :1]; +} +export fn fn711() void { + _ = src_ptr40[3.. :1]; +} +export fn fn712() void { + _ = src_ptr40[3..2 :1]; +} +export fn fn713() void { + _ = src_ptr40[3..3 :1]; +} +export fn fn714() void { + _ = src_ptr40[3..1 :1]; +} +export fn fn715() void { + dest_end = 3; + _ = src_ptr40[3..dest_end :1]; +} +export fn fn716() void { + dest_end = 1; + _ = src_ptr40[3..dest_end :1]; +} +export fn fn717() void { + _ = src_ptr40[3..][0..2 :1]; +} +export fn fn718() void { + _ = src_ptr40[3..][0..3 :1]; +} +export fn fn719() void { + _ = src_ptr40[3..][0..1 :1]; +} +export fn fn720() void { + dest_len = 3; + _ = src_ptr40[3..][0..dest_len :1]; +} +export fn fn721() void { + dest_len = 1; + _ = src_ptr40[3..][0..dest_len :1]; +} +var src_mem26: [1]u8 = .{0}; +var src_ptr41: *[0:0]u8 = src_mem26[0..0 :0]; +export fn fn722() void { + _ = src_ptr41[0..2]; +} +export fn fn723() void { + _ = src_ptr41[0..3]; +} +export fn fn724() void { + _ = src_ptr41[0..][0..2]; +} +export fn fn725() void { + _ = src_ptr41[0..][0..3]; +} +export fn fn726() void { + _ = src_ptr41[1..]; +} +export fn fn727() void { + _ = src_ptr41[1..2]; +} +export fn fn728() void { + _ = src_ptr41[1..3]; +} +export fn fn729() void { + _ = src_ptr41[1..][0..2]; +} +export fn fn730() void { + _ = src_ptr41[1..][0..3]; +} +export fn fn731() void { + _ = src_ptr41[1..][0..1]; +} +export fn fn732() void { + _ = src_ptr41[3..]; +} +export fn fn733() void { + _ = src_ptr41[3..2]; +} +export fn fn734() void { + _ = src_ptr41[3..3]; +} +export fn fn735() void { + _ = src_ptr41[3..1]; +} +export fn fn736() void { + dest_end = 3; + _ = src_ptr41[3..dest_end]; +} +export fn fn737() void { + dest_end = 1; + _ = src_ptr41[3..dest_end]; +} +export fn fn738() void { + _ = src_ptr41[3..][0..2]; +} +export fn fn739() void { + _ = src_ptr41[3..][0..3]; +} +export fn fn740() void { + _ = src_ptr41[3..][0..1]; +} +export fn fn741() void { + dest_len = 3; + _ = src_ptr41[3..][0..dest_len]; +} +export fn fn742() void { + dest_len = 1; + _ = src_ptr41[3..][0..dest_len]; +} +export fn fn743() void { + _ = src_ptr41[0..2 :1]; +} +export fn fn744() void { + _ = src_ptr41[0..3 :1]; +} +export fn fn745() void { + _ = src_ptr41[0..1 :1]; +} +export fn fn746() void { + _ = src_ptr41[0..][0..2 :1]; +} +export fn fn747() void { + _ = src_ptr41[0..][0..3 :1]; +} +export fn fn748() void { + _ = src_ptr41[0..][0..1 :1]; +} +export fn fn749() void { + _ = src_ptr41[1.. :1]; +} +export fn fn750() void { + _ = src_ptr41[1..2 :1]; +} +export fn fn751() void { + _ = src_ptr41[1..3 :1]; +} +export fn fn752() void { + _ = src_ptr41[1..1 :1]; +} +export fn fn753() void { + dest_end = 3; + _ = src_ptr41[1..dest_end :1]; +} +export fn fn754() void { + dest_end = 1; + _ = src_ptr41[1..dest_end :1]; +} +export fn fn755() void { + _ = src_ptr41[1..][0..2 :1]; +} +export fn fn756() void { + _ = src_ptr41[1..][0..3 :1]; +} +export fn fn757() void { + _ = src_ptr41[1..][0..1 :1]; +} +export fn fn758() void { + dest_len = 3; + _ = src_ptr41[1..][0..dest_len :1]; +} +export fn fn759() void { + dest_len = 1; + _ = src_ptr41[1..][0..dest_len :1]; +} +export fn fn760() void { + _ = src_ptr41[3.. :1]; +} +export fn fn761() void { + _ = src_ptr41[3..2 :1]; +} +export fn fn762() void { + _ = src_ptr41[3..3 :1]; +} +export fn fn763() void { + _ = src_ptr41[3..1 :1]; +} +export fn fn764() void { + dest_end = 3; + _ = src_ptr41[3..dest_end :1]; +} +export fn fn765() void { + dest_end = 1; + _ = src_ptr41[3..dest_end :1]; +} +export fn fn766() void { + _ = src_ptr41[3..][0..2 :1]; +} +export fn fn767() void { + _ = src_ptr41[3..][0..3 :1]; +} +export fn fn768() void { + _ = src_ptr41[3..][0..1 :1]; +} +export fn fn769() void { + dest_len = 3; + _ = src_ptr41[3..][0..dest_len :1]; +} +export fn fn770() void { + dest_len = 1; + _ = src_ptr41[3..][0..dest_len :1]; +} +const src_ptr42: []u8 = src_mem15[0..2]; +export fn fn771() void { + _ = src_ptr42[0..3]; +} +export fn fn772() void { + _ = src_ptr42[0..][0..3]; +} +export fn fn773() void { + _ = src_ptr42[1..3]; +} +export fn fn774() void { + _ = src_ptr42[1..][0..2]; +} +export fn fn775() void { + _ = src_ptr42[1..][0..3]; +} +export fn fn776() void { + _ = src_ptr42[3..]; +} +export fn fn777() void { + _ = src_ptr42[3..2]; +} +export fn fn778() void { + _ = src_ptr42[3..3]; +} +export fn fn779() void { + _ = src_ptr42[3..1]; +} +export fn fn780() void { + dest_end = 3; + _ = src_ptr42[3..dest_end]; +} +export fn fn781() void { + dest_end = 1; + _ = src_ptr42[3..dest_end]; +} +export fn fn782() void { + _ = src_ptr42[3..][0..2]; +} +export fn fn783() void { + _ = src_ptr42[3..][0..3]; +} +export fn fn784() void { + _ = src_ptr42[3..][0..1]; +} +export fn fn785() void { + dest_len = 3; + _ = src_ptr42[3..][0..dest_len]; +} +export fn fn786() void { + dest_len = 1; + _ = src_ptr42[3..][0..dest_len]; +} +export fn fn787() void { + _ = src_ptr42[0.. :1]; +} +export fn fn788() void { + _ = src_ptr42[0..2 :1]; +} +export fn fn789() void { + _ = src_ptr42[0..3 :1]; +} +export fn fn790() void { + _ = src_ptr42[0..][0..2 :1]; +} +export fn fn791() void { + _ = src_ptr42[0..][0..3 :1]; +} +export fn fn792() void { + _ = src_ptr42[1.. :1]; +} +export fn fn793() void { + _ = src_ptr42[1..2 :1]; +} +export fn fn794() void { + _ = src_ptr42[1..3 :1]; +} +export fn fn795() void { + _ = src_ptr42[1..][0..2 :1]; +} +export fn fn796() void { + _ = src_ptr42[1..][0..3 :1]; +} +export fn fn797() void { + _ = src_ptr42[1..][0..1 :1]; +} +export fn fn798() void { + _ = src_ptr42[3.. :1]; +} +export fn fn799() void { + _ = src_ptr42[3..2 :1]; +} +export fn fn800() void { + _ = src_ptr42[3..3 :1]; +} +export fn fn801() void { + _ = src_ptr42[3..1 :1]; +} +export fn fn802() void { + dest_end = 3; + _ = src_ptr42[3..dest_end :1]; +} +export fn fn803() void { + dest_end = 1; + _ = src_ptr42[3..dest_end :1]; +} +export fn fn804() void { + _ = src_ptr42[3..][0..2 :1]; +} +export fn fn805() void { + _ = src_ptr42[3..][0..3 :1]; +} +export fn fn806() void { + _ = src_ptr42[3..][0..1 :1]; +} +export fn fn807() void { + dest_len = 3; + _ = src_ptr42[3..][0..dest_len :1]; +} +export fn fn808() void { + dest_len = 1; + _ = src_ptr42[3..][0..dest_len :1]; +} +const src_ptr43: [:0]u8 = src_mem16[0..1 :0]; +export fn fn809() void { + _ = src_ptr43[0..3]; +} +export fn fn810() void { + _ = src_ptr43[0..][0..3]; +} +export fn fn811() void { + _ = src_ptr43[1..3]; +} +export fn fn812() void { + _ = src_ptr43[1..][0..2]; +} +export fn fn813() void { + _ = src_ptr43[1..][0..3]; +} +export fn fn814() void { + _ = src_ptr43[3..]; +} +export fn fn815() void { + _ = src_ptr43[3..2]; +} +export fn fn816() void { + _ = src_ptr43[3..3]; +} +export fn fn817() void { + _ = src_ptr43[3..1]; +} +export fn fn818() void { + dest_end = 3; + _ = src_ptr43[3..dest_end]; +} +export fn fn819() void { + dest_end = 1; + _ = src_ptr43[3..dest_end]; +} +export fn fn820() void { + _ = src_ptr43[3..][0..2]; +} +export fn fn821() void { + _ = src_ptr43[3..][0..3]; +} +export fn fn822() void { + _ = src_ptr43[3..][0..1]; +} +export fn fn823() void { + dest_len = 3; + _ = src_ptr43[3..][0..dest_len]; +} +export fn fn824() void { + dest_len = 1; + _ = src_ptr43[3..][0..dest_len]; +} +export fn fn825() void { + _ = src_ptr43[0..2 :1]; +} +export fn fn826() void { + _ = src_ptr43[0..3 :1]; +} +export fn fn827() void { + _ = src_ptr43[0..][0..2 :1]; +} +export fn fn828() void { + _ = src_ptr43[0..][0..3 :1]; +} +export fn fn829() void { + _ = src_ptr43[1..2 :1]; +} +export fn fn830() void { + _ = src_ptr43[1..3 :1]; +} +export fn fn831() void { + _ = src_ptr43[1..][0..2 :1]; +} +export fn fn832() void { + _ = src_ptr43[1..][0..3 :1]; +} +export fn fn833() void { + _ = src_ptr43[1..][0..1 :1]; +} +export fn fn834() void { + _ = src_ptr43[3.. :1]; +} +export fn fn835() void { + _ = src_ptr43[3..2 :1]; +} +export fn fn836() void { + _ = src_ptr43[3..3 :1]; +} +export fn fn837() void { + _ = src_ptr43[3..1 :1]; +} +export fn fn838() void { + dest_end = 3; + _ = src_ptr43[3..dest_end :1]; +} +export fn fn839() void { + dest_end = 1; + _ = src_ptr43[3..dest_end :1]; +} +export fn fn840() void { + _ = src_ptr43[3..][0..2 :1]; +} +export fn fn841() void { + _ = src_ptr43[3..][0..3 :1]; +} +export fn fn842() void { + _ = src_ptr43[3..][0..1 :1]; +} +export fn fn843() void { + dest_len = 3; + _ = src_ptr43[3..][0..dest_len :1]; +} +export fn fn844() void { + dest_len = 1; + _ = src_ptr43[3..][0..dest_len :1]; +} +const src_ptr44: []u8 = src_mem17[0..3]; +export fn fn845() void { + _ = src_ptr44[1..][0..3]; +} +export fn fn846() void { + _ = src_ptr44[3..2]; +} +export fn fn847() void { + _ = src_ptr44[3..1]; +} +export fn fn848() void { + _ = src_ptr44[3..][0..2]; +} +export fn fn849() void { + _ = src_ptr44[3..][0..3]; +} +export fn fn850() void { + _ = src_ptr44[3..][0..1]; +} +export fn fn851() void { + _ = src_ptr44[0.. :1]; +} +export fn fn852() void { + _ = src_ptr44[0..3 :1]; +} +export fn fn853() void { + _ = src_ptr44[0..][0..3 :1]; +} +export fn fn854() void { + _ = src_ptr44[1.. :1]; +} +export fn fn855() void { + _ = src_ptr44[1..3 :1]; +} +export fn fn856() void { + _ = src_ptr44[1..][0..2 :1]; +} +export fn fn857() void { + _ = src_ptr44[1..][0..3 :1]; +} +export fn fn858() void { + _ = src_ptr44[3.. :1]; +} +export fn fn859() void { + _ = src_ptr44[3..2 :1]; +} +export fn fn860() void { + _ = src_ptr44[3..3 :1]; +} +export fn fn861() void { + _ = src_ptr44[3..1 :1]; +} +export fn fn862() void { + dest_end = 3; + _ = src_ptr44[3..dest_end :1]; +} +export fn fn863() void { + dest_end = 1; + _ = src_ptr44[3..dest_end :1]; +} +export fn fn864() void { + _ = src_ptr44[3..][0..2 :1]; +} +export fn fn865() void { + _ = src_ptr44[3..][0..3 :1]; +} +export fn fn866() void { + _ = src_ptr44[3..][0..1 :1]; +} +export fn fn867() void { + dest_len = 3; + _ = src_ptr44[3..][0..dest_len :1]; +} +export fn fn868() void { + dest_len = 1; + _ = src_ptr44[3..][0..dest_len :1]; +} +const src_ptr45: [:0]u8 = src_mem18[0..2 :0]; +export fn fn869() void { + _ = src_ptr45[1..][0..3]; +} +export fn fn870() void { + _ = src_ptr45[3..]; +} +export fn fn871() void { + _ = src_ptr45[3..2]; +} +export fn fn872() void { + _ = src_ptr45[3..1]; +} +export fn fn873() void { + _ = src_ptr45[3..][0..2]; +} +export fn fn874() void { + _ = src_ptr45[3..][0..3]; +} +export fn fn875() void { + _ = src_ptr45[3..][0..1]; +} +export fn fn876() void { + _ = src_ptr45[0..3 :1]; +} +export fn fn877() void { + _ = src_ptr45[0..][0..3 :1]; +} +export fn fn878() void { + _ = src_ptr45[1..3 :1]; +} +export fn fn879() void { + _ = src_ptr45[1..][0..2 :1]; +} +export fn fn880() void { + _ = src_ptr45[1..][0..3 :1]; +} +export fn fn881() void { + _ = src_ptr45[3.. :1]; +} +export fn fn882() void { + _ = src_ptr45[3..2 :1]; +} +export fn fn883() void { + _ = src_ptr45[3..3 :1]; +} +export fn fn884() void { + _ = src_ptr45[3..1 :1]; +} +export fn fn885() void { + dest_end = 3; + _ = src_ptr45[3..dest_end :1]; +} +export fn fn886() void { + dest_end = 1; + _ = src_ptr45[3..dest_end :1]; +} +export fn fn887() void { + _ = src_ptr45[3..][0..2 :1]; +} +export fn fn888() void { + _ = src_ptr45[3..][0..3 :1]; +} +export fn fn889() void { + _ = src_ptr45[3..][0..1 :1]; +} +export fn fn890() void { + dest_len = 3; + _ = src_ptr45[3..][0..dest_len :1]; +} +export fn fn891() void { + dest_len = 1; + _ = src_ptr45[3..][0..dest_len :1]; +} +const src_ptr46: []u8 = src_mem19[0..1]; +export fn fn892() void { + _ = src_ptr46[0..2]; +} +export fn fn893() void { + _ = src_ptr46[0..3]; +} +export fn fn894() void { + _ = src_ptr46[0..][0..2]; +} +export fn fn895() void { + _ = src_ptr46[0..][0..3]; +} +export fn fn896() void { + _ = src_ptr46[1..2]; +} +export fn fn897() void { + _ = src_ptr46[1..3]; +} +export fn fn898() void { + _ = src_ptr46[1..][0..2]; +} +export fn fn899() void { + _ = src_ptr46[1..][0..3]; +} +export fn fn900() void { + _ = src_ptr46[1..][0..1]; +} +export fn fn901() void { + _ = src_ptr46[3..]; +} +export fn fn902() void { + _ = src_ptr46[3..2]; +} +export fn fn903() void { + _ = src_ptr46[3..3]; +} +export fn fn904() void { + _ = src_ptr46[3..1]; +} +export fn fn905() void { + dest_end = 3; + _ = src_ptr46[3..dest_end]; +} +export fn fn906() void { + dest_end = 1; + _ = src_ptr46[3..dest_end]; +} +export fn fn907() void { + _ = src_ptr46[3..][0..2]; +} +export fn fn908() void { + _ = src_ptr46[3..][0..3]; +} +export fn fn909() void { + _ = src_ptr46[3..][0..1]; +} +export fn fn910() void { + dest_len = 3; + _ = src_ptr46[3..][0..dest_len]; +} +export fn fn911() void { + dest_len = 1; + _ = src_ptr46[3..][0..dest_len]; +} +export fn fn912() void { + _ = src_ptr46[0.. :1]; +} +export fn fn913() void { + _ = src_ptr46[0..2 :1]; +} +export fn fn914() void { + _ = src_ptr46[0..3 :1]; +} +export fn fn915() void { + _ = src_ptr46[0..1 :1]; +} +export fn fn916() void { + _ = src_ptr46[0..][0..2 :1]; +} +export fn fn917() void { + _ = src_ptr46[0..][0..3 :1]; +} +export fn fn918() void { + _ = src_ptr46[0..][0..1 :1]; +} +export fn fn919() void { + _ = src_ptr46[1.. :1]; +} +export fn fn920() void { + _ = src_ptr46[1..2 :1]; +} +export fn fn921() void { + _ = src_ptr46[1..3 :1]; +} +export fn fn922() void { + _ = src_ptr46[1..1 :1]; +} +export fn fn923() void { + dest_end = 3; + _ = src_ptr46[1..dest_end :1]; +} +export fn fn924() void { + dest_end = 1; + _ = src_ptr46[1..dest_end :1]; +} +export fn fn925() void { + _ = src_ptr46[1..][0..2 :1]; +} +export fn fn926() void { + _ = src_ptr46[1..][0..3 :1]; +} +export fn fn927() void { + _ = src_ptr46[1..][0..1 :1]; +} +export fn fn928() void { + dest_len = 3; + _ = src_ptr46[1..][0..dest_len :1]; +} +export fn fn929() void { + dest_len = 1; + _ = src_ptr46[1..][0..dest_len :1]; +} +export fn fn930() void { + _ = src_ptr46[3.. :1]; +} +export fn fn931() void { + _ = src_ptr46[3..2 :1]; +} +export fn fn932() void { + _ = src_ptr46[3..3 :1]; +} +export fn fn933() void { + _ = src_ptr46[3..1 :1]; +} +export fn fn934() void { + dest_end = 3; + _ = src_ptr46[3..dest_end :1]; +} +export fn fn935() void { + dest_end = 1; + _ = src_ptr46[3..dest_end :1]; +} +export fn fn936() void { + _ = src_ptr46[3..][0..2 :1]; +} +export fn fn937() void { + _ = src_ptr46[3..][0..3 :1]; +} +export fn fn938() void { + _ = src_ptr46[3..][0..1 :1]; +} +export fn fn939() void { + dest_len = 3; + _ = src_ptr46[3..][0..dest_len :1]; +} +export fn fn940() void { + dest_len = 1; + _ = src_ptr46[3..][0..dest_len :1]; +} +const src_ptr47: [:0]u8 = src_mem20[0..0 :0]; +export fn fn941() void { + _ = src_ptr47[0..2]; +} +export fn fn942() void { + _ = src_ptr47[0..3]; +} +export fn fn943() void { + _ = src_ptr47[0..][0..2]; +} +export fn fn944() void { + _ = src_ptr47[0..][0..3]; +} +export fn fn945() void { + _ = src_ptr47[1..]; +} +export fn fn946() void { + _ = src_ptr47[1..2]; +} +export fn fn947() void { + _ = src_ptr47[1..3]; +} +export fn fn948() void { + _ = src_ptr47[1..][0..2]; +} +export fn fn949() void { + _ = src_ptr47[1..][0..3]; +} +export fn fn950() void { + _ = src_ptr47[1..][0..1]; +} +export fn fn951() void { + _ = src_ptr47[3..]; +} +export fn fn952() void { + _ = src_ptr47[3..2]; +} +export fn fn953() void { + _ = src_ptr47[3..3]; +} +export fn fn954() void { + _ = src_ptr47[3..1]; +} +export fn fn955() void { + dest_end = 3; + _ = src_ptr47[3..dest_end]; +} +export fn fn956() void { + dest_end = 1; + _ = src_ptr47[3..dest_end]; +} +export fn fn957() void { + _ = src_ptr47[3..][0..2]; +} +export fn fn958() void { + _ = src_ptr47[3..][0..3]; +} +export fn fn959() void { + _ = src_ptr47[3..][0..1]; +} +export fn fn960() void { + dest_len = 3; + _ = src_ptr47[3..][0..dest_len]; +} +export fn fn961() void { + dest_len = 1; + _ = src_ptr47[3..][0..dest_len]; +} +export fn fn962() void { + _ = src_ptr47[0..2 :1]; +} +export fn fn963() void { + _ = src_ptr47[0..3 :1]; +} +export fn fn964() void { + _ = src_ptr47[0..1 :1]; +} +export fn fn965() void { + _ = src_ptr47[0..][0..2 :1]; +} +export fn fn966() void { + _ = src_ptr47[0..][0..3 :1]; +} +export fn fn967() void { + _ = src_ptr47[0..][0..1 :1]; +} +export fn fn968() void { + _ = src_ptr47[1.. :1]; +} +export fn fn969() void { + _ = src_ptr47[1..2 :1]; +} +export fn fn970() void { + _ = src_ptr47[1..3 :1]; +} +export fn fn971() void { + _ = src_ptr47[1..1 :1]; +} +export fn fn972() void { + dest_end = 3; + _ = src_ptr47[1..dest_end :1]; +} +export fn fn973() void { + dest_end = 1; + _ = src_ptr47[1..dest_end :1]; +} +export fn fn974() void { + _ = src_ptr47[1..][0..2 :1]; +} +export fn fn975() void { + _ = src_ptr47[1..][0..3 :1]; +} +export fn fn976() void { + _ = src_ptr47[1..][0..1 :1]; +} +export fn fn977() void { + dest_len = 3; + _ = src_ptr47[1..][0..dest_len :1]; +} +export fn fn978() void { + dest_len = 1; + _ = src_ptr47[1..][0..dest_len :1]; +} +export fn fn979() void { + _ = src_ptr47[3.. :1]; +} +export fn fn980() void { + _ = src_ptr47[3..2 :1]; +} +export fn fn981() void { + _ = src_ptr47[3..3 :1]; +} +export fn fn982() void { + _ = src_ptr47[3..1 :1]; +} +export fn fn983() void { + dest_end = 3; + _ = src_ptr47[3..dest_end :1]; +} +export fn fn984() void { + dest_end = 1; + _ = src_ptr47[3..dest_end :1]; +} +export fn fn985() void { + _ = src_ptr47[3..][0..2 :1]; +} +export fn fn986() void { + _ = src_ptr47[3..][0..3 :1]; +} +export fn fn987() void { + _ = src_ptr47[3..][0..1 :1]; +} +export fn fn988() void { + dest_len = 3; + _ = src_ptr47[3..][0..dest_len :1]; +} +export fn fn989() void { + dest_len = 1; + _ = src_ptr47[3..][0..dest_len :1]; +} +var src_mem27: [2]u8 = .{ 0, 0 }; +var src_ptr48: []u8 = src_mem27[0..2]; +export fn fn990() void { + _ = src_ptr48[3..2]; +} +export fn fn991() void { + _ = src_ptr48[3..1]; +} +export fn fn992() void { + _ = src_ptr48[0.. :1]; +} +export fn fn993() void { + _ = src_ptr48[1.. :1]; +} +export fn fn994() void { + _ = src_ptr48[3.. :1]; +} +export fn fn995() void { + _ = src_ptr48[3..2 :1]; +} +export fn fn996() void { + _ = src_ptr48[3..1 :1]; +} +var src_mem28: [2]u8 = .{ 0, 0 }; +var src_ptr49: [:0]u8 = src_mem28[0..1 :0]; +export fn fn997() void { + _ = src_ptr49[3..2]; +} +export fn fn998() void { + _ = src_ptr49[3..1]; +} +export fn fn999() void { + _ = src_ptr49[3..2 :1]; +} +export fn fn1000() void { + _ = src_ptr49[3..1 :1]; +} +var src_mem29: [3]u8 = .{ 0, 0, 0 }; +var src_ptr50: []u8 = src_mem29[0..3]; +export fn fn1001() void { + _ = src_ptr50[3..2]; +} +export fn fn1002() void { + _ = src_ptr50[3..1]; +} +export fn fn1003() void { + _ = src_ptr50[0.. :1]; +} +export fn fn1004() void { + _ = src_ptr50[1.. :1]; +} +export fn fn1005() void { + _ = src_ptr50[3.. :1]; +} +export fn fn1006() void { + _ = src_ptr50[3..2 :1]; +} +export fn fn1007() void { + _ = src_ptr50[3..1 :1]; +} +var src_mem30: [3]u8 = .{ 0, 0, 0 }; +var src_ptr51: [:0]u8 = src_mem30[0..2 :0]; +export fn fn1008() void { + _ = src_ptr51[3..2]; +} +export fn fn1009() void { + _ = src_ptr51[3..1]; +} +export fn fn1010() void { + _ = src_ptr51[3..2 :1]; +} +export fn fn1011() void { + _ = src_ptr51[3..1 :1]; +} +var src_mem31: [1]u8 = .{0}; +var src_ptr52: []u8 = src_mem31[0..1]; +export fn fn1012() void { + _ = src_ptr52[3..2]; +} +export fn fn1013() void { + _ = src_ptr52[3..1]; +} +export fn fn1014() void { + _ = src_ptr52[0.. :1]; +} +export fn fn1015() void { + _ = src_ptr52[1.. :1]; +} +export fn fn1016() void { + _ = src_ptr52[3.. :1]; +} +export fn fn1017() void { + _ = src_ptr52[3..2 :1]; +} +export fn fn1018() void { + _ = src_ptr52[3..1 :1]; +} +var src_mem32: [1]u8 = .{0}; +var src_ptr53: [:0]u8 = src_mem32[0..0 :0]; +export fn fn1019() void { + _ = src_ptr53[3..2]; +} +export fn fn1020() void { + _ = src_ptr53[3..1]; +} +export fn fn1021() void { + _ = src_ptr53[3..2 :1]; +} +export fn fn1022() void { + _ = src_ptr53[3..1 :1]; +} +const src_ptr54: [*]u8 = @ptrCast(&src_mem15); +export fn fn1023() void { + _ = src_ptr54[0..3]; +} +export fn fn1024() void { + _ = src_ptr54[0..][0..3]; +} +export fn fn1025() void { + _ = src_ptr54[1..3]; +} +export fn fn1026() void { + _ = src_ptr54[1..][0..2]; +} +export fn fn1027() void { + _ = src_ptr54[1..][0..3]; +} +export fn fn1028() void { + _ = src_ptr54[3..]; +} +export fn fn1029() void { + _ = src_ptr54[3..2]; +} +export fn fn1030() void { + _ = src_ptr54[3..3]; +} +export fn fn1031() void { + _ = src_ptr54[3..1]; +} +export fn fn1032() void { + dest_end = 3; + _ = src_ptr54[3..dest_end]; +} +export fn fn1033() void { + dest_end = 1; + _ = src_ptr54[3..dest_end]; +} +export fn fn1034() void { + _ = src_ptr54[3..][0..2]; +} +export fn fn1035() void { + _ = src_ptr54[3..][0..3]; +} +export fn fn1036() void { + _ = src_ptr54[3..][0..1]; +} +export fn fn1037() void { + dest_len = 3; + _ = src_ptr54[3..][0..dest_len]; +} +export fn fn1038() void { + dest_len = 1; + _ = src_ptr54[3..][0..dest_len]; +} +export fn fn1039() void { + _ = src_ptr54[0..2 :1]; +} +export fn fn1040() void { + _ = src_ptr54[0..3 :1]; +} +export fn fn1041() void { + _ = src_ptr54[0..][0..2 :1]; +} +export fn fn1042() void { + _ = src_ptr54[0..][0..3 :1]; +} +export fn fn1043() void { + _ = src_ptr54[1..2 :1]; +} +export fn fn1044() void { + _ = src_ptr54[1..3 :1]; +} +export fn fn1045() void { + _ = src_ptr54[1..][0..2 :1]; +} +export fn fn1046() void { + _ = src_ptr54[1..][0..3 :1]; +} +export fn fn1047() void { + _ = src_ptr54[1..][0..1 :1]; +} +export fn fn1048() void { + _ = src_ptr54[3.. :1]; +} +export fn fn1049() void { + _ = src_ptr54[3..2 :1]; +} +export fn fn1050() void { + _ = src_ptr54[3..3 :1]; +} +export fn fn1051() void { + _ = src_ptr54[3..1 :1]; +} +export fn fn1052() void { + dest_end = 3; + _ = src_ptr54[3..dest_end :1]; +} +export fn fn1053() void { + dest_end = 1; + _ = src_ptr54[3..dest_end :1]; +} +export fn fn1054() void { + _ = src_ptr54[3..][0..2 :1]; +} +export fn fn1055() void { + _ = src_ptr54[3..][0..3 :1]; +} +export fn fn1056() void { + _ = src_ptr54[3..][0..1 :1]; +} +export fn fn1057() void { + dest_len = 3; + _ = src_ptr54[3..][0..dest_len :1]; +} +export fn fn1058() void { + dest_len = 1; + _ = src_ptr54[3..][0..dest_len :1]; +} +const src_ptr55: [*:0]u8 = @ptrCast(&src_mem16); +export fn fn1059() void { + _ = src_ptr55[0..3]; +} +export fn fn1060() void { + _ = src_ptr55[0..][0..3]; +} +export fn fn1061() void { + _ = src_ptr55[1..3]; +} +export fn fn1062() void { + _ = src_ptr55[1..][0..2]; +} +export fn fn1063() void { + _ = src_ptr55[1..][0..3]; +} +export fn fn1064() void { + _ = src_ptr55[3..]; +} +export fn fn1065() void { + _ = src_ptr55[3..2]; +} +export fn fn1066() void { + _ = src_ptr55[3..3]; +} +export fn fn1067() void { + _ = src_ptr55[3..1]; +} +export fn fn1068() void { + dest_end = 3; + _ = src_ptr55[3..dest_end]; +} +export fn fn1069() void { + dest_end = 1; + _ = src_ptr55[3..dest_end]; +} +export fn fn1070() void { + _ = src_ptr55[3..][0..2]; +} +export fn fn1071() void { + _ = src_ptr55[3..][0..3]; +} +export fn fn1072() void { + _ = src_ptr55[3..][0..1]; +} +export fn fn1073() void { + dest_len = 3; + _ = src_ptr55[3..][0..dest_len]; +} +export fn fn1074() void { + dest_len = 1; + _ = src_ptr55[3..][0..dest_len]; +} +export fn fn1075() void { + _ = src_ptr55[0..2 :1]; +} +export fn fn1076() void { + _ = src_ptr55[0..3 :1]; +} +export fn fn1077() void { + _ = src_ptr55[0..][0..2 :1]; +} +export fn fn1078() void { + _ = src_ptr55[0..][0..3 :1]; +} +export fn fn1079() void { + _ = src_ptr55[1..2 :1]; +} +export fn fn1080() void { + _ = src_ptr55[1..3 :1]; +} +export fn fn1081() void { + _ = src_ptr55[1..][0..2 :1]; +} +export fn fn1082() void { + _ = src_ptr55[1..][0..3 :1]; +} +export fn fn1083() void { + _ = src_ptr55[1..][0..1 :1]; +} +export fn fn1084() void { + _ = src_ptr55[3.. :1]; +} +export fn fn1085() void { + _ = src_ptr55[3..2 :1]; +} +export fn fn1086() void { + _ = src_ptr55[3..3 :1]; +} +export fn fn1087() void { + _ = src_ptr55[3..1 :1]; +} +export fn fn1088() void { + dest_end = 3; + _ = src_ptr55[3..dest_end :1]; +} +export fn fn1089() void { + dest_end = 1; + _ = src_ptr55[3..dest_end :1]; +} +export fn fn1090() void { + _ = src_ptr55[3..][0..2 :1]; +} +export fn fn1091() void { + _ = src_ptr55[3..][0..3 :1]; +} +export fn fn1092() void { + _ = src_ptr55[3..][0..1 :1]; +} +export fn fn1093() void { + dest_len = 3; + _ = src_ptr55[3..][0..dest_len :1]; +} +export fn fn1094() void { + dest_len = 1; + _ = src_ptr55[3..][0..dest_len :1]; +} +const src_ptr56: [*]u8 = @ptrCast(&src_mem17); +export fn fn1095() void { + _ = src_ptr56[1..][0..3]; +} +export fn fn1096() void { + _ = src_ptr56[3..2]; +} +export fn fn1097() void { + _ = src_ptr56[3..1]; +} +export fn fn1098() void { + _ = src_ptr56[3..][0..2]; +} +export fn fn1099() void { + _ = src_ptr56[3..][0..3]; +} +export fn fn1100() void { + _ = src_ptr56[3..][0..1]; +} +export fn fn1101() void { + _ = src_ptr56[0..3 :1]; +} +export fn fn1102() void { + _ = src_ptr56[0..][0..3 :1]; +} +export fn fn1103() void { + _ = src_ptr56[1..3 :1]; +} +export fn fn1104() void { + _ = src_ptr56[1..][0..2 :1]; +} +export fn fn1105() void { + _ = src_ptr56[1..][0..3 :1]; +} +export fn fn1106() void { + _ = src_ptr56[3.. :1]; +} +export fn fn1107() void { + _ = src_ptr56[3..2 :1]; +} +export fn fn1108() void { + _ = src_ptr56[3..3 :1]; +} +export fn fn1109() void { + _ = src_ptr56[3..1 :1]; +} +export fn fn1110() void { + dest_end = 3; + _ = src_ptr56[3..dest_end :1]; +} +export fn fn1111() void { + dest_end = 1; + _ = src_ptr56[3..dest_end :1]; +} +export fn fn1112() void { + _ = src_ptr56[3..][0..2 :1]; +} +export fn fn1113() void { + _ = src_ptr56[3..][0..3 :1]; +} +export fn fn1114() void { + _ = src_ptr56[3..][0..1 :1]; +} +export fn fn1115() void { + dest_len = 3; + _ = src_ptr56[3..][0..dest_len :1]; +} +export fn fn1116() void { + dest_len = 1; + _ = src_ptr56[3..][0..dest_len :1]; +} +const src_ptr57: [*:0]u8 = @ptrCast(&src_mem18); +export fn fn1117() void { + _ = src_ptr57[1..][0..3]; +} +export fn fn1118() void { + _ = src_ptr57[3..2]; +} +export fn fn1119() void { + _ = src_ptr57[3..1]; +} +export fn fn1120() void { + _ = src_ptr57[3..][0..2]; +} +export fn fn1121() void { + _ = src_ptr57[3..][0..3]; +} +export fn fn1122() void { + _ = src_ptr57[3..][0..1]; +} +export fn fn1123() void { + _ = src_ptr57[0..3 :1]; +} +export fn fn1124() void { + _ = src_ptr57[0..][0..3 :1]; +} +export fn fn1125() void { + _ = src_ptr57[1..3 :1]; +} +export fn fn1126() void { + _ = src_ptr57[1..][0..2 :1]; +} +export fn fn1127() void { + _ = src_ptr57[1..][0..3 :1]; +} +export fn fn1128() void { + _ = src_ptr57[3.. :1]; +} +export fn fn1129() void { + _ = src_ptr57[3..2 :1]; +} +export fn fn1130() void { + _ = src_ptr57[3..3 :1]; +} +export fn fn1131() void { + _ = src_ptr57[3..1 :1]; +} +export fn fn1132() void { + dest_end = 3; + _ = src_ptr57[3..dest_end :1]; +} +export fn fn1133() void { + dest_end = 1; + _ = src_ptr57[3..dest_end :1]; +} +export fn fn1134() void { + _ = src_ptr57[3..][0..2 :1]; +} +export fn fn1135() void { + _ = src_ptr57[3..][0..3 :1]; +} +export fn fn1136() void { + _ = src_ptr57[3..][0..1 :1]; +} +export fn fn1137() void { + dest_len = 3; + _ = src_ptr57[3..][0..dest_len :1]; +} +export fn fn1138() void { + dest_len = 1; + _ = src_ptr57[3..][0..dest_len :1]; +} +const src_ptr58: [*]u8 = @ptrCast(&src_mem19); +export fn fn1139() void { + _ = src_ptr58[0..2]; +} +export fn fn1140() void { + _ = src_ptr58[0..3]; +} +export fn fn1141() void { + _ = src_ptr58[0..][0..2]; +} +export fn fn1142() void { + _ = src_ptr58[0..][0..3]; +} +export fn fn1143() void { + _ = src_ptr58[1..2]; +} +export fn fn1144() void { + _ = src_ptr58[1..3]; +} +export fn fn1145() void { + _ = src_ptr58[1..][0..2]; +} +export fn fn1146() void { + _ = src_ptr58[1..][0..3]; +} +export fn fn1147() void { + _ = src_ptr58[1..][0..1]; +} +export fn fn1148() void { + _ = src_ptr58[3..]; +} +export fn fn1149() void { + _ = src_ptr58[3..2]; +} +export fn fn1150() void { + _ = src_ptr58[3..3]; +} +export fn fn1151() void { + _ = src_ptr58[3..1]; +} +export fn fn1152() void { + dest_end = 3; + _ = src_ptr58[3..dest_end]; +} +export fn fn1153() void { + dest_end = 1; + _ = src_ptr58[3..dest_end]; +} +export fn fn1154() void { + _ = src_ptr58[3..][0..2]; +} +export fn fn1155() void { + _ = src_ptr58[3..][0..3]; +} +export fn fn1156() void { + _ = src_ptr58[3..][0..1]; +} +export fn fn1157() void { + dest_len = 3; + _ = src_ptr58[3..][0..dest_len]; +} +export fn fn1158() void { + dest_len = 1; + _ = src_ptr58[3..][0..dest_len]; +} +export fn fn1159() void { + _ = src_ptr58[0..2 :1]; +} +export fn fn1160() void { + _ = src_ptr58[0..3 :1]; +} +export fn fn1161() void { + _ = src_ptr58[0..1 :1]; +} +export fn fn1162() void { + _ = src_ptr58[0..][0..2 :1]; +} +export fn fn1163() void { + _ = src_ptr58[0..][0..3 :1]; +} +export fn fn1164() void { + _ = src_ptr58[0..][0..1 :1]; +} +export fn fn1165() void { + _ = src_ptr58[1.. :1]; +} +export fn fn1166() void { + _ = src_ptr58[1..2 :1]; +} +export fn fn1167() void { + _ = src_ptr58[1..3 :1]; +} +export fn fn1168() void { + _ = src_ptr58[1..1 :1]; +} +export fn fn1169() void { + dest_end = 3; + _ = src_ptr58[1..dest_end :1]; +} +export fn fn1170() void { + dest_end = 1; + _ = src_ptr58[1..dest_end :1]; +} +export fn fn1171() void { + _ = src_ptr58[1..][0..2 :1]; +} +export fn fn1172() void { + _ = src_ptr58[1..][0..3 :1]; +} +export fn fn1173() void { + _ = src_ptr58[1..][0..1 :1]; +} +export fn fn1174() void { + dest_len = 3; + _ = src_ptr58[1..][0..dest_len :1]; +} +export fn fn1175() void { + dest_len = 1; + _ = src_ptr58[1..][0..dest_len :1]; +} +export fn fn1176() void { + _ = src_ptr58[3.. :1]; +} +export fn fn1177() void { + _ = src_ptr58[3..2 :1]; +} +export fn fn1178() void { + _ = src_ptr58[3..3 :1]; +} +export fn fn1179() void { + _ = src_ptr58[3..1 :1]; +} +export fn fn1180() void { + dest_end = 3; + _ = src_ptr58[3..dest_end :1]; +} +export fn fn1181() void { + dest_end = 1; + _ = src_ptr58[3..dest_end :1]; +} +export fn fn1182() void { + _ = src_ptr58[3..][0..2 :1]; +} +export fn fn1183() void { + _ = src_ptr58[3..][0..3 :1]; +} +export fn fn1184() void { + _ = src_ptr58[3..][0..1 :1]; +} +export fn fn1185() void { + dest_len = 3; + _ = src_ptr58[3..][0..dest_len :1]; +} +export fn fn1186() void { + dest_len = 1; + _ = src_ptr58[3..][0..dest_len :1]; +} +const src_ptr59: [*:0]u8 = @ptrCast(&src_mem20); +export fn fn1187() void { + _ = src_ptr59[0..2]; +} +export fn fn1188() void { + _ = src_ptr59[0..3]; +} +export fn fn1189() void { + _ = src_ptr59[0..][0..2]; +} +export fn fn1190() void { + _ = src_ptr59[0..][0..3]; +} +export fn fn1191() void { + _ = src_ptr59[1..2]; +} +export fn fn1192() void { + _ = src_ptr59[1..3]; +} +export fn fn1193() void { + _ = src_ptr59[1..][0..2]; +} +export fn fn1194() void { + _ = src_ptr59[1..][0..3]; +} +export fn fn1195() void { + _ = src_ptr59[1..][0..1]; +} +export fn fn1196() void { + _ = src_ptr59[3..]; +} +export fn fn1197() void { + _ = src_ptr59[3..2]; +} +export fn fn1198() void { + _ = src_ptr59[3..3]; +} +export fn fn1199() void { + _ = src_ptr59[3..1]; +} +export fn fn1200() void { + dest_end = 3; + _ = src_ptr59[3..dest_end]; +} +export fn fn1201() void { + dest_end = 1; + _ = src_ptr59[3..dest_end]; +} +export fn fn1202() void { + _ = src_ptr59[3..][0..2]; +} +export fn fn1203() void { + _ = src_ptr59[3..][0..3]; +} +export fn fn1204() void { + _ = src_ptr59[3..][0..1]; +} +export fn fn1205() void { + dest_len = 3; + _ = src_ptr59[3..][0..dest_len]; +} +export fn fn1206() void { + dest_len = 1; + _ = src_ptr59[3..][0..dest_len]; +} +export fn fn1207() void { + _ = src_ptr59[0..2 :1]; +} +export fn fn1208() void { + _ = src_ptr59[0..3 :1]; +} +export fn fn1209() void { + _ = src_ptr59[0..1 :1]; +} +export fn fn1210() void { + _ = src_ptr59[0..][0..2 :1]; +} +export fn fn1211() void { + _ = src_ptr59[0..][0..3 :1]; +} +export fn fn1212() void { + _ = src_ptr59[0..][0..1 :1]; +} +export fn fn1213() void { + _ = src_ptr59[1.. :1]; +} +export fn fn1214() void { + _ = src_ptr59[1..2 :1]; +} +export fn fn1215() void { + _ = src_ptr59[1..3 :1]; +} +export fn fn1216() void { + _ = src_ptr59[1..1 :1]; +} +export fn fn1217() void { + dest_end = 3; + _ = src_ptr59[1..dest_end :1]; +} +export fn fn1218() void { + dest_end = 1; + _ = src_ptr59[1..dest_end :1]; +} +export fn fn1219() void { + _ = src_ptr59[1..][0..2 :1]; +} +export fn fn1220() void { + _ = src_ptr59[1..][0..3 :1]; +} +export fn fn1221() void { + _ = src_ptr59[1..][0..1 :1]; +} +export fn fn1222() void { + dest_len = 3; + _ = src_ptr59[1..][0..dest_len :1]; +} +export fn fn1223() void { + dest_len = 1; + _ = src_ptr59[1..][0..dest_len :1]; +} +export fn fn1224() void { + _ = src_ptr59[3.. :1]; +} +export fn fn1225() void { + _ = src_ptr59[3..2 :1]; +} +export fn fn1226() void { + _ = src_ptr59[3..3 :1]; +} +export fn fn1227() void { + _ = src_ptr59[3..1 :1]; +} +export fn fn1228() void { + dest_end = 3; + _ = src_ptr59[3..dest_end :1]; +} +export fn fn1229() void { + dest_end = 1; + _ = src_ptr59[3..dest_end :1]; +} +export fn fn1230() void { + _ = src_ptr59[3..][0..2 :1]; +} +export fn fn1231() void { + _ = src_ptr59[3..][0..3 :1]; +} +export fn fn1232() void { + _ = src_ptr59[3..][0..1 :1]; +} +export fn fn1233() void { + dest_len = 3; + _ = src_ptr59[3..][0..dest_len :1]; +} +export fn fn1234() void { + dest_len = 1; + _ = src_ptr59[3..][0..dest_len :1]; +} +var src_mem33: [2]u8 = .{ 0, 0 }; +var src_ptr60: [*]u8 = @ptrCast(&src_mem33); +export fn fn1235() void { + _ = src_ptr60[3..2]; +} +export fn fn1236() void { + _ = src_ptr60[3..1]; +} +export fn fn1237() void { + _ = src_ptr60[3..2 :1]; +} +export fn fn1238() void { + _ = src_ptr60[3..1 :1]; +} +var src_mem34: [2]u8 = .{ 0, 0 }; +var src_ptr61: [*:0]u8 = @ptrCast(&src_mem34); +export fn fn1239() void { + _ = src_ptr61[3..2]; +} +export fn fn1240() void { + _ = src_ptr61[3..1]; +} +export fn fn1241() void { + _ = src_ptr61[3..2 :1]; +} +export fn fn1242() void { + _ = src_ptr61[3..1 :1]; +} +var src_mem35: [3]u8 = .{ 0, 0, 0 }; +var src_ptr62: [*]u8 = @ptrCast(&src_mem35); +export fn fn1243() void { + _ = src_ptr62[3..2]; +} +export fn fn1244() void { + _ = src_ptr62[3..1]; +} +export fn fn1245() void { + _ = src_ptr62[3..2 :1]; +} +export fn fn1246() void { + _ = src_ptr62[3..1 :1]; +} +var src_mem36: [3]u8 = .{ 0, 0, 0 }; +var src_ptr63: [*:0]u8 = @ptrCast(&src_mem36); +export fn fn1247() void { + _ = src_ptr63[3..2]; +} +export fn fn1248() void { + _ = src_ptr63[3..1]; +} +export fn fn1249() void { + _ = src_ptr63[3..2 :1]; +} +export fn fn1250() void { + _ = src_ptr63[3..1 :1]; +} +var src_mem37: [1]u8 = .{0}; +var src_ptr64: [*]u8 = @ptrCast(&src_mem37); +export fn fn1251() void { + _ = src_ptr64[3..2]; +} +export fn fn1252() void { + _ = src_ptr64[3..1]; +} +export fn fn1253() void { + _ = src_ptr64[3..2 :1]; +} +export fn fn1254() void { + _ = src_ptr64[3..1 :1]; +} +var src_mem38: [1]u8 = .{0}; +var src_ptr65: [*:0]u8 = @ptrCast(&src_mem38); +export fn fn1255() void { + _ = src_ptr65[3..2]; +} +export fn fn1256() void { + _ = src_ptr65[3..1]; +} +export fn fn1257() void { + _ = src_ptr65[3..2 :1]; +} +export fn fn1258() void { + _ = src_ptr65[3..1 :1]; +} +const src_ptr66: [*c]u8 = nullptr; +export fn fn1259() void { + _ = src_ptr66[0..]; +} +export fn fn1260() void { + _ = src_ptr66[0..2]; +} +export fn fn1261() void { + _ = src_ptr66[0..3]; +} +export fn fn1262() void { + _ = src_ptr66[0..1]; +} +export fn fn1263() void { + dest_end = 3; + _ = src_ptr66[0..dest_end]; +} +export fn fn1264() void { + dest_end = 1; + _ = src_ptr66[0..dest_end]; +} +export fn fn1265() void { + _ = src_ptr66[0..][0..2]; +} +export fn fn1266() void { + _ = src_ptr66[0..][0..3]; +} +export fn fn1267() void { + _ = src_ptr66[0..][0..1]; +} +export fn fn1268() void { + dest_len = 3; + _ = src_ptr66[0..][0..dest_len]; +} +export fn fn1269() void { + dest_len = 1; + _ = src_ptr66[0..][0..dest_len]; +} +export fn fn1270() void { + _ = src_ptr66[1..]; +} +export fn fn1271() void { + _ = src_ptr66[1..2]; +} +export fn fn1272() void { + _ = src_ptr66[1..3]; +} +export fn fn1273() void { + _ = src_ptr66[1..1]; +} +export fn fn1274() void { + dest_end = 3; + _ = src_ptr66[1..dest_end]; +} +export fn fn1275() void { + dest_end = 1; + _ = src_ptr66[1..dest_end]; +} +export fn fn1276() void { + _ = src_ptr66[1..][0..2]; +} +export fn fn1277() void { + _ = src_ptr66[1..][0..3]; +} +export fn fn1278() void { + _ = src_ptr66[1..][0..1]; +} +export fn fn1279() void { + dest_len = 3; + _ = src_ptr66[1..][0..dest_len]; +} +export fn fn1280() void { + dest_len = 1; + _ = src_ptr66[1..][0..dest_len]; +} +export fn fn1281() void { + _ = src_ptr66[3..]; +} +export fn fn1282() void { + _ = src_ptr66[3..2]; +} +export fn fn1283() void { + _ = src_ptr66[3..3]; +} +export fn fn1284() void { + _ = src_ptr66[3..1]; +} +export fn fn1285() void { + dest_end = 3; + _ = src_ptr66[3..dest_end]; +} +export fn fn1286() void { + dest_end = 1; + _ = src_ptr66[3..dest_end]; +} +export fn fn1287() void { + _ = src_ptr66[3..][0..2]; +} +export fn fn1288() void { + _ = src_ptr66[3..][0..3]; +} +export fn fn1289() void { + _ = src_ptr66[3..][0..1]; +} +export fn fn1290() void { + dest_len = 3; + _ = src_ptr66[3..][0..dest_len]; +} +export fn fn1291() void { + dest_len = 1; + _ = src_ptr66[3..][0..dest_len]; +} +export fn fn1292() void { + _ = src_ptr66[0.. :1]; +} +export fn fn1293() void { + _ = src_ptr66[0..2 :1]; +} +export fn fn1294() void { + _ = src_ptr66[0..3 :1]; +} +export fn fn1295() void { + _ = src_ptr66[0..1 :1]; +} +export fn fn1296() void { + dest_end = 3; + _ = src_ptr66[0..dest_end :1]; +} +export fn fn1297() void { + dest_end = 1; + _ = src_ptr66[0..dest_end :1]; +} +export fn fn1298() void { + _ = src_ptr66[0..][0..2 :1]; +} +export fn fn1299() void { + _ = src_ptr66[0..][0..3 :1]; +} +export fn fn1300() void { + _ = src_ptr66[0..][0..1 :1]; +} +export fn fn1301() void { + dest_len = 3; + _ = src_ptr66[0..][0..dest_len :1]; +} +export fn fn1302() void { + dest_len = 1; + _ = src_ptr66[0..][0..dest_len :1]; +} +export fn fn1303() void { + _ = src_ptr66[1.. :1]; +} +export fn fn1304() void { + _ = src_ptr66[1..2 :1]; +} +export fn fn1305() void { + _ = src_ptr66[1..3 :1]; +} +export fn fn1306() void { + _ = src_ptr66[1..1 :1]; +} +export fn fn1307() void { + dest_end = 3; + _ = src_ptr66[1..dest_end :1]; +} +export fn fn1308() void { + dest_end = 1; + _ = src_ptr66[1..dest_end :1]; +} +export fn fn1309() void { + _ = src_ptr66[1..][0..2 :1]; +} +export fn fn1310() void { + _ = src_ptr66[1..][0..3 :1]; +} +export fn fn1311() void { + _ = src_ptr66[1..][0..1 :1]; +} +export fn fn1312() void { + dest_len = 3; + _ = src_ptr66[1..][0..dest_len :1]; +} +export fn fn1313() void { + dest_len = 1; + _ = src_ptr66[1..][0..dest_len :1]; +} +export fn fn1314() void { + _ = src_ptr66[3.. :1]; +} +export fn fn1315() void { + _ = src_ptr66[3..2 :1]; +} +export fn fn1316() void { + _ = src_ptr66[3..3 :1]; +} +export fn fn1317() void { + _ = src_ptr66[3..1 :1]; +} +export fn fn1318() void { + dest_end = 3; + _ = src_ptr66[3..dest_end :1]; +} +export fn fn1319() void { + dest_end = 1; + _ = src_ptr66[3..dest_end :1]; +} +export fn fn1320() void { + _ = src_ptr66[3..][0..2 :1]; +} +export fn fn1321() void { + _ = src_ptr66[3..][0..3 :1]; +} +export fn fn1322() void { + _ = src_ptr66[3..][0..1 :1]; +} +export fn fn1323() void { + dest_len = 3; + _ = src_ptr66[3..][0..dest_len :1]; +} +export fn fn1324() void { + dest_len = 1; + _ = src_ptr66[3..][0..dest_len :1]; +} +const src_ptr67: [*c]u8 = nullptr; +export fn fn1325() void { + _ = src_ptr67[0..]; +} +export fn fn1326() void { + _ = src_ptr67[0..2]; +} +export fn fn1327() void { + _ = src_ptr67[0..3]; +} +export fn fn1328() void { + _ = src_ptr67[0..1]; +} +export fn fn1329() void { + dest_end = 3; + _ = src_ptr67[0..dest_end]; +} +export fn fn1330() void { + dest_end = 1; + _ = src_ptr67[0..dest_end]; +} +export fn fn1331() void { + _ = src_ptr67[0..][0..2]; +} +export fn fn1332() void { + _ = src_ptr67[0..][0..3]; +} +export fn fn1333() void { + _ = src_ptr67[0..][0..1]; +} +export fn fn1334() void { + dest_len = 3; + _ = src_ptr67[0..][0..dest_len]; +} +export fn fn1335() void { + dest_len = 1; + _ = src_ptr67[0..][0..dest_len]; +} +export fn fn1336() void { + _ = src_ptr67[1..]; +} +export fn fn1337() void { + _ = src_ptr67[1..2]; +} +export fn fn1338() void { + _ = src_ptr67[1..3]; +} +export fn fn1339() void { + _ = src_ptr67[1..1]; +} +export fn fn1340() void { + dest_end = 3; + _ = src_ptr67[1..dest_end]; +} +export fn fn1341() void { + dest_end = 1; + _ = src_ptr67[1..dest_end]; +} +export fn fn1342() void { + _ = src_ptr67[1..][0..2]; +} +export fn fn1343() void { + _ = src_ptr67[1..][0..3]; +} +export fn fn1344() void { + _ = src_ptr67[1..][0..1]; +} +export fn fn1345() void { + dest_len = 3; + _ = src_ptr67[1..][0..dest_len]; +} +export fn fn1346() void { + dest_len = 1; + _ = src_ptr67[1..][0..dest_len]; +} +export fn fn1347() void { + _ = src_ptr67[3..]; +} +export fn fn1348() void { + _ = src_ptr67[3..2]; +} +export fn fn1349() void { + _ = src_ptr67[3..3]; +} +export fn fn1350() void { + _ = src_ptr67[3..1]; +} +export fn fn1351() void { + dest_end = 3; + _ = src_ptr67[3..dest_end]; +} +export fn fn1352() void { + dest_end = 1; + _ = src_ptr67[3..dest_end]; +} +export fn fn1353() void { + _ = src_ptr67[3..][0..2]; +} +export fn fn1354() void { + _ = src_ptr67[3..][0..3]; +} +export fn fn1355() void { + _ = src_ptr67[3..][0..1]; +} +export fn fn1356() void { + dest_len = 3; + _ = src_ptr67[3..][0..dest_len]; +} +export fn fn1357() void { + dest_len = 1; + _ = src_ptr67[3..][0..dest_len]; +} +export fn fn1358() void { + _ = src_ptr67[0.. :1]; +} +export fn fn1359() void { + _ = src_ptr67[0..2 :1]; +} +export fn fn1360() void { + _ = src_ptr67[0..3 :1]; +} +export fn fn1361() void { + _ = src_ptr67[0..1 :1]; +} +export fn fn1362() void { + dest_end = 3; + _ = src_ptr67[0..dest_end :1]; +} +export fn fn1363() void { + dest_end = 1; + _ = src_ptr67[0..dest_end :1]; +} +export fn fn1364() void { + _ = src_ptr67[0..][0..2 :1]; +} +export fn fn1365() void { + _ = src_ptr67[0..][0..3 :1]; +} +export fn fn1366() void { + _ = src_ptr67[0..][0..1 :1]; +} +export fn fn1367() void { + dest_len = 3; + _ = src_ptr67[0..][0..dest_len :1]; +} +export fn fn1368() void { + dest_len = 1; + _ = src_ptr67[0..][0..dest_len :1]; +} +export fn fn1369() void { + _ = src_ptr67[1.. :1]; +} +export fn fn1370() void { + _ = src_ptr67[1..2 :1]; +} +export fn fn1371() void { + _ = src_ptr67[1..3 :1]; +} +export fn fn1372() void { + _ = src_ptr67[1..1 :1]; +} +export fn fn1373() void { + dest_end = 3; + _ = src_ptr67[1..dest_end :1]; +} +export fn fn1374() void { + dest_end = 1; + _ = src_ptr67[1..dest_end :1]; +} +export fn fn1375() void { + _ = src_ptr67[1..][0..2 :1]; +} +export fn fn1376() void { + _ = src_ptr67[1..][0..3 :1]; +} +export fn fn1377() void { + _ = src_ptr67[1..][0..1 :1]; +} +export fn fn1378() void { + dest_len = 3; + _ = src_ptr67[1..][0..dest_len :1]; +} +export fn fn1379() void { + dest_len = 1; + _ = src_ptr67[1..][0..dest_len :1]; +} +export fn fn1380() void { + _ = src_ptr67[3.. :1]; +} +export fn fn1381() void { + _ = src_ptr67[3..2 :1]; +} +export fn fn1382() void { + _ = src_ptr67[3..3 :1]; +} +export fn fn1383() void { + _ = src_ptr67[3..1 :1]; +} +export fn fn1384() void { + dest_end = 3; + _ = src_ptr67[3..dest_end :1]; +} +export fn fn1385() void { + dest_end = 1; + _ = src_ptr67[3..dest_end :1]; +} +export fn fn1386() void { + _ = src_ptr67[3..][0..2 :1]; +} +export fn fn1387() void { + _ = src_ptr67[3..][0..3 :1]; +} +export fn fn1388() void { + _ = src_ptr67[3..][0..1 :1]; +} +export fn fn1389() void { + dest_len = 3; + _ = src_ptr67[3..][0..dest_len :1]; +} +export fn fn1390() void { + dest_len = 1; + _ = src_ptr67[3..][0..dest_len :1]; +} +const src_ptr68: [*c]u8 = nullptr; +export fn fn1391() void { + _ = src_ptr68[0..]; +} +export fn fn1392() void { + _ = src_ptr68[0..2]; +} +export fn fn1393() void { + _ = src_ptr68[0..3]; +} +export fn fn1394() void { + _ = src_ptr68[0..1]; +} +export fn fn1395() void { + dest_end = 3; + _ = src_ptr68[0..dest_end]; +} +export fn fn1396() void { + dest_end = 1; + _ = src_ptr68[0..dest_end]; +} +export fn fn1397() void { + _ = src_ptr68[0..][0..2]; +} +export fn fn1398() void { + _ = src_ptr68[0..][0..3]; +} +export fn fn1399() void { + _ = src_ptr68[0..][0..1]; +} +export fn fn1400() void { + dest_len = 3; + _ = src_ptr68[0..][0..dest_len]; +} +export fn fn1401() void { + dest_len = 1; + _ = src_ptr68[0..][0..dest_len]; +} +export fn fn1402() void { + _ = src_ptr68[1..]; +} +export fn fn1403() void { + _ = src_ptr68[1..2]; +} +export fn fn1404() void { + _ = src_ptr68[1..3]; +} +export fn fn1405() void { + _ = src_ptr68[1..1]; +} +export fn fn1406() void { + dest_end = 3; + _ = src_ptr68[1..dest_end]; +} +export fn fn1407() void { + dest_end = 1; + _ = src_ptr68[1..dest_end]; +} +export fn fn1408() void { + _ = src_ptr68[1..][0..2]; +} +export fn fn1409() void { + _ = src_ptr68[1..][0..3]; +} +export fn fn1410() void { + _ = src_ptr68[1..][0..1]; +} +export fn fn1411() void { + dest_len = 3; + _ = src_ptr68[1..][0..dest_len]; +} +export fn fn1412() void { + dest_len = 1; + _ = src_ptr68[1..][0..dest_len]; +} +export fn fn1413() void { + _ = src_ptr68[3..]; +} +export fn fn1414() void { + _ = src_ptr68[3..2]; +} +export fn fn1415() void { + _ = src_ptr68[3..3]; +} +export fn fn1416() void { + _ = src_ptr68[3..1]; +} +export fn fn1417() void { + dest_end = 3; + _ = src_ptr68[3..dest_end]; +} +export fn fn1418() void { + dest_end = 1; + _ = src_ptr68[3..dest_end]; +} +export fn fn1419() void { + _ = src_ptr68[3..][0..2]; +} +export fn fn1420() void { + _ = src_ptr68[3..][0..3]; +} +export fn fn1421() void { + _ = src_ptr68[3..][0..1]; +} +export fn fn1422() void { + dest_len = 3; + _ = src_ptr68[3..][0..dest_len]; +} +export fn fn1423() void { + dest_len = 1; + _ = src_ptr68[3..][0..dest_len]; +} +export fn fn1424() void { + _ = src_ptr68[0.. :1]; +} +export fn fn1425() void { + _ = src_ptr68[0..2 :1]; +} +export fn fn1426() void { + _ = src_ptr68[0..3 :1]; +} +export fn fn1427() void { + _ = src_ptr68[0..1 :1]; +} +export fn fn1428() void { + dest_end = 3; + _ = src_ptr68[0..dest_end :1]; +} +export fn fn1429() void { + dest_end = 1; + _ = src_ptr68[0..dest_end :1]; +} +export fn fn1430() void { + _ = src_ptr68[0..][0..2 :1]; +} +export fn fn1431() void { + _ = src_ptr68[0..][0..3 :1]; +} +export fn fn1432() void { + _ = src_ptr68[0..][0..1 :1]; +} +export fn fn1433() void { + dest_len = 3; + _ = src_ptr68[0..][0..dest_len :1]; +} +export fn fn1434() void { + dest_len = 1; + _ = src_ptr68[0..][0..dest_len :1]; +} +export fn fn1435() void { + _ = src_ptr68[1.. :1]; +} +export fn fn1436() void { + _ = src_ptr68[1..2 :1]; +} +export fn fn1437() void { + _ = src_ptr68[1..3 :1]; +} +export fn fn1438() void { + _ = src_ptr68[1..1 :1]; +} +export fn fn1439() void { + dest_end = 3; + _ = src_ptr68[1..dest_end :1]; +} +export fn fn1440() void { + dest_end = 1; + _ = src_ptr68[1..dest_end :1]; +} +export fn fn1441() void { + _ = src_ptr68[1..][0..2 :1]; +} +export fn fn1442() void { + _ = src_ptr68[1..][0..3 :1]; +} +export fn fn1443() void { + _ = src_ptr68[1..][0..1 :1]; +} +export fn fn1444() void { + dest_len = 3; + _ = src_ptr68[1..][0..dest_len :1]; +} +export fn fn1445() void { + dest_len = 1; + _ = src_ptr68[1..][0..dest_len :1]; +} +export fn fn1446() void { + _ = src_ptr68[3.. :1]; +} +export fn fn1447() void { + _ = src_ptr68[3..2 :1]; +} +export fn fn1448() void { + _ = src_ptr68[3..3 :1]; +} +export fn fn1449() void { + _ = src_ptr68[3..1 :1]; +} +export fn fn1450() void { + dest_end = 3; + _ = src_ptr68[3..dest_end :1]; +} +export fn fn1451() void { + dest_end = 1; + _ = src_ptr68[3..dest_end :1]; +} +export fn fn1452() void { + _ = src_ptr68[3..][0..2 :1]; +} +export fn fn1453() void { + _ = src_ptr68[3..][0..3 :1]; +} +export fn fn1454() void { + _ = src_ptr68[3..][0..1 :1]; +} +export fn fn1455() void { + dest_len = 3; + _ = src_ptr68[3..][0..dest_len :1]; +} +export fn fn1456() void { + dest_len = 1; + _ = src_ptr68[3..][0..dest_len :1]; +} +var src_ptr69: [*c]u8 = null; +export fn fn1457() void { + _ = src_ptr69[3..2]; +} +export fn fn1458() void { + _ = src_ptr69[3..1]; +} +export fn fn1459() void { + _ = src_ptr69[3..2 :1]; +} +export fn fn1460() void { + _ = src_ptr69[3..1 :1]; +} +var src_ptr70: [*c]u8 = null; +export fn fn1461() void { + _ = src_ptr70[3..2]; +} +export fn fn1462() void { + _ = src_ptr70[3..1]; +} +export fn fn1463() void { + _ = src_ptr70[3..2 :1]; +} +export fn fn1464() void { + _ = src_ptr70[3..1 :1]; +} +var src_ptr71: [*c]u8 = null; +export fn fn1465() void { + _ = src_ptr71[3..2]; +} +export fn fn1466() void { + _ = src_ptr71[3..1]; +} +export fn fn1467() void { + _ = src_ptr71[3..2 :1]; +} +export fn fn1468() void { + _ = src_ptr71[3..1 :1]; +} +const src_ptr72: [*c]u8 = @ptrCast(&src_mem15); +export fn fn1469() void { + _ = src_ptr72[0..3]; +} +export fn fn1470() void { + _ = src_ptr72[0..][0..3]; +} +export fn fn1471() void { + _ = src_ptr72[1..3]; +} +export fn fn1472() void { + _ = src_ptr72[1..][0..2]; +} +export fn fn1473() void { + _ = src_ptr72[1..][0..3]; +} +export fn fn1474() void { + _ = src_ptr72[3..]; +} +export fn fn1475() void { + _ = src_ptr72[3..2]; +} +export fn fn1476() void { + _ = src_ptr72[3..3]; +} +export fn fn1477() void { + _ = src_ptr72[3..1]; +} +export fn fn1478() void { + dest_end = 3; + _ = src_ptr72[3..dest_end]; +} +export fn fn1479() void { + dest_end = 1; + _ = src_ptr72[3..dest_end]; +} +export fn fn1480() void { + _ = src_ptr72[3..][0..2]; +} +export fn fn1481() void { + _ = src_ptr72[3..][0..3]; +} +export fn fn1482() void { + _ = src_ptr72[3..][0..1]; +} +export fn fn1483() void { + dest_len = 3; + _ = src_ptr72[3..][0..dest_len]; +} +export fn fn1484() void { + dest_len = 1; + _ = src_ptr72[3..][0..dest_len]; +} +export fn fn1485() void { + _ = src_ptr72[0..2 :1]; +} +export fn fn1486() void { + _ = src_ptr72[0..3 :1]; +} +export fn fn1487() void { + _ = src_ptr72[0..][0..2 :1]; +} +export fn fn1488() void { + _ = src_ptr72[0..][0..3 :1]; +} +export fn fn1489() void { + _ = src_ptr72[1..2 :1]; +} +export fn fn1490() void { + _ = src_ptr72[1..3 :1]; +} +export fn fn1491() void { + _ = src_ptr72[1..][0..2 :1]; +} +export fn fn1492() void { + _ = src_ptr72[1..][0..3 :1]; +} +export fn fn1493() void { + _ = src_ptr72[1..][0..1 :1]; +} +export fn fn1494() void { + _ = src_ptr72[3.. :1]; +} +export fn fn1495() void { + _ = src_ptr72[3..2 :1]; +} +export fn fn1496() void { + _ = src_ptr72[3..3 :1]; +} +export fn fn1497() void { + _ = src_ptr72[3..1 :1]; +} +export fn fn1498() void { + dest_end = 3; + _ = src_ptr72[3..dest_end :1]; +} +export fn fn1499() void { + dest_end = 1; + _ = src_ptr72[3..dest_end :1]; +} +export fn fn1500() void { + _ = src_ptr72[3..][0..2 :1]; +} +export fn fn1501() void { + _ = src_ptr72[3..][0..3 :1]; +} +export fn fn1502() void { + _ = src_ptr72[3..][0..1 :1]; +} +export fn fn1503() void { + dest_len = 3; + _ = src_ptr72[3..][0..dest_len :1]; +} +export fn fn1504() void { + dest_len = 1; + _ = src_ptr72[3..][0..dest_len :1]; +} +const src_ptr73: [*c]u8 = @ptrCast(&src_mem17); +export fn fn1505() void { + _ = src_ptr73[1..][0..3]; +} +export fn fn1506() void { + _ = src_ptr73[3..2]; +} +export fn fn1507() void { + _ = src_ptr73[3..1]; +} +export fn fn1508() void { + _ = src_ptr73[3..][0..2]; +} +export fn fn1509() void { + _ = src_ptr73[3..][0..3]; +} +export fn fn1510() void { + _ = src_ptr73[3..][0..1]; +} +export fn fn1511() void { + _ = src_ptr73[0..3 :1]; +} +export fn fn1512() void { + _ = src_ptr73[0..][0..3 :1]; +} +export fn fn1513() void { + _ = src_ptr73[1..3 :1]; +} +export fn fn1514() void { + _ = src_ptr73[1..][0..2 :1]; +} +export fn fn1515() void { + _ = src_ptr73[1..][0..3 :1]; +} +export fn fn1516() void { + _ = src_ptr73[3.. :1]; +} +export fn fn1517() void { + _ = src_ptr73[3..2 :1]; +} +export fn fn1518() void { + _ = src_ptr73[3..3 :1]; +} +export fn fn1519() void { + _ = src_ptr73[3..1 :1]; +} +export fn fn1520() void { + dest_end = 3; + _ = src_ptr73[3..dest_end :1]; +} +export fn fn1521() void { + dest_end = 1; + _ = src_ptr73[3..dest_end :1]; +} +export fn fn1522() void { + _ = src_ptr73[3..][0..2 :1]; +} +export fn fn1523() void { + _ = src_ptr73[3..][0..3 :1]; +} +export fn fn1524() void { + _ = src_ptr73[3..][0..1 :1]; +} +export fn fn1525() void { + dest_len = 3; + _ = src_ptr73[3..][0..dest_len :1]; +} +export fn fn1526() void { + dest_len = 1; + _ = src_ptr73[3..][0..dest_len :1]; +} +const src_ptr74: [*c]u8 = @ptrCast(&src_mem19); +export fn fn1527() void { + _ = src_ptr74[0..2]; +} +export fn fn1528() void { + _ = src_ptr74[0..3]; +} +export fn fn1529() void { + _ = src_ptr74[0..][0..2]; +} +export fn fn1530() void { + _ = src_ptr74[0..][0..3]; +} +export fn fn1531() void { + _ = src_ptr74[1..2]; +} +export fn fn1532() void { + _ = src_ptr74[1..3]; +} +export fn fn1533() void { + _ = src_ptr74[1..][0..2]; +} +export fn fn1534() void { + _ = src_ptr74[1..][0..3]; +} +export fn fn1535() void { + _ = src_ptr74[1..][0..1]; +} +export fn fn1536() void { + _ = src_ptr74[3..]; +} +export fn fn1537() void { + _ = src_ptr74[3..2]; +} +export fn fn1538() void { + _ = src_ptr74[3..3]; +} +export fn fn1539() void { + _ = src_ptr74[3..1]; +} +export fn fn1540() void { + dest_end = 3; + _ = src_ptr74[3..dest_end]; +} +export fn fn1541() void { + dest_end = 1; + _ = src_ptr74[3..dest_end]; +} +export fn fn1542() void { + _ = src_ptr74[3..][0..2]; +} +export fn fn1543() void { + _ = src_ptr74[3..][0..3]; +} +export fn fn1544() void { + _ = src_ptr74[3..][0..1]; +} +export fn fn1545() void { + dest_len = 3; + _ = src_ptr74[3..][0..dest_len]; +} +export fn fn1546() void { + dest_len = 1; + _ = src_ptr74[3..][0..dest_len]; +} +export fn fn1547() void { + _ = src_ptr74[0..2 :1]; +} +export fn fn1548() void { + _ = src_ptr74[0..3 :1]; +} +export fn fn1549() void { + _ = src_ptr74[0..1 :1]; +} +export fn fn1550() void { + _ = src_ptr74[0..][0..2 :1]; +} +export fn fn1551() void { + _ = src_ptr74[0..][0..3 :1]; +} +export fn fn1552() void { + _ = src_ptr74[0..][0..1 :1]; +} +export fn fn1553() void { + _ = src_ptr74[1.. :1]; +} +export fn fn1554() void { + _ = src_ptr74[1..2 :1]; +} +export fn fn1555() void { + _ = src_ptr74[1..3 :1]; +} +export fn fn1556() void { + _ = src_ptr74[1..1 :1]; +} +export fn fn1557() void { + dest_end = 3; + _ = src_ptr74[1..dest_end :1]; +} +export fn fn1558() void { + dest_end = 1; + _ = src_ptr74[1..dest_end :1]; +} +export fn fn1559() void { + _ = src_ptr74[1..][0..2 :1]; +} +export fn fn1560() void { + _ = src_ptr74[1..][0..3 :1]; +} +export fn fn1561() void { + _ = src_ptr74[1..][0..1 :1]; +} +export fn fn1562() void { + dest_len = 3; + _ = src_ptr74[1..][0..dest_len :1]; +} +export fn fn1563() void { + dest_len = 1; + _ = src_ptr74[1..][0..dest_len :1]; +} +export fn fn1564() void { + _ = src_ptr74[3.. :1]; +} +export fn fn1565() void { + _ = src_ptr74[3..2 :1]; +} +export fn fn1566() void { + _ = src_ptr74[3..3 :1]; +} +export fn fn1567() void { + _ = src_ptr74[3..1 :1]; +} +export fn fn1568() void { + dest_end = 3; + _ = src_ptr74[3..dest_end :1]; +} +export fn fn1569() void { + dest_end = 1; + _ = src_ptr74[3..dest_end :1]; +} +export fn fn1570() void { + _ = src_ptr74[3..][0..2 :1]; +} +export fn fn1571() void { + _ = src_ptr74[3..][0..3 :1]; +} +export fn fn1572() void { + _ = src_ptr74[3..][0..1 :1]; +} +export fn fn1573() void { + dest_len = 3; + _ = src_ptr74[3..][0..dest_len :1]; +} +export fn fn1574() void { + dest_len = 1; + _ = src_ptr74[3..][0..dest_len :1]; +} +var src_mem39: [2]u8 = .{ 0, 0 }; +var src_ptr75: [*c]u8 = @ptrCast(&src_mem39); +export fn fn1575() void { + _ = src_ptr75[3..2]; +} +export fn fn1576() void { + _ = src_ptr75[3..1]; +} +export fn fn1577() void { + _ = src_ptr75[3..2 :1]; +} +export fn fn1578() void { + _ = src_ptr75[3..1 :1]; +} +var src_mem40: [3]u8 = .{ 0, 0, 0 }; +var src_ptr76: [*c]u8 = @ptrCast(&src_mem40); +export fn fn1579() void { + _ = src_ptr76[3..2]; +} +export fn fn1580() void { + _ = src_ptr76[3..1]; +} +export fn fn1581() void { + _ = src_ptr76[3..2 :1]; +} +export fn fn1582() void { + _ = src_ptr76[3..1 :1]; +} +var src_mem41: [1]u8 = .{0}; +var src_ptr77: [*c]u8 = @ptrCast(&src_mem41); +export fn fn1583() void { + _ = src_ptr77[3..2]; +} +export fn fn1584() void { + _ = src_ptr77[3..1]; +} +export fn fn1585() void { + _ = src_ptr77[3..2 :1]; +} +export fn fn1586() void { + _ = src_ptr77[3..1 :1]; +} +const src_mem42: [2]u8 = .{ 0, 0 }; +const src_ptr78: *const [2]u8 = src_mem42[0..2]; +comptime { + _ = src_ptr78[0..3]; +} +comptime { + _ = src_ptr78[0..][0..3]; +} +comptime { + _ = src_ptr78[1..3]; +} +comptime { + _ = src_ptr78[1..][0..2]; +} +comptime { + _ = src_ptr78[1..][0..3]; +} +comptime { + _ = src_ptr78[3..]; +} +comptime { + _ = src_ptr78[3..2]; +} +comptime { + _ = src_ptr78[3..3]; +} +comptime { + _ = src_ptr78[3..1]; +} +export fn fn1587() void { + dest_end = 3; + _ = src_ptr78[3..dest_end]; +} +export fn fn1588() void { + dest_end = 1; + _ = src_ptr78[3..dest_end]; +} +comptime { + _ = src_ptr78[3..][0..2]; +} +comptime { + _ = src_ptr78[3..][0..3]; +} +comptime { + _ = src_ptr78[3..][0..1]; +} +export fn fn1589() void { + dest_len = 3; + _ = src_ptr78[3..][0..dest_len]; +} +export fn fn1590() void { + dest_len = 1; + _ = src_ptr78[3..][0..dest_len]; +} +comptime { + _ = src_ptr78[0.. :1]; +} +comptime { + _ = src_ptr78[0..2 :1]; +} +comptime { + _ = src_ptr78[0..3 :1]; +} +comptime { + _ = src_ptr78[0..1 :1]; +} +comptime { + _ = src_ptr78[0..][0..2 :1]; +} +comptime { + _ = src_ptr78[0..][0..3 :1]; +} +comptime { + _ = src_ptr78[0..][0..1 :1]; +} +comptime { + _ = src_ptr78[1.. :1]; +} +comptime { + _ = src_ptr78[1..2 :1]; +} +comptime { + _ = src_ptr78[1..3 :1]; +} +comptime { + _ = src_ptr78[1..1 :1]; +} +comptime { + _ = src_ptr78[1..][0..2 :1]; +} +comptime { + _ = src_ptr78[1..][0..3 :1]; +} +comptime { + _ = src_ptr78[1..][0..1 :1]; +} +comptime { + _ = src_ptr78[3.. :1]; +} +comptime { + _ = src_ptr78[3..2 :1]; +} +comptime { + _ = src_ptr78[3..3 :1]; +} +comptime { + _ = src_ptr78[3..1 :1]; +} +export fn fn1591() void { + dest_end = 3; + _ = src_ptr78[3..dest_end :1]; +} +export fn fn1592() void { + dest_end = 1; + _ = src_ptr78[3..dest_end :1]; +} +comptime { + _ = src_ptr78[3..][0..2 :1]; +} +comptime { + _ = src_ptr78[3..][0..3 :1]; +} +comptime { + _ = src_ptr78[3..][0..1 :1]; +} +export fn fn1593() void { + dest_len = 3; + _ = src_ptr78[3..][0..dest_len :1]; +} +export fn fn1594() void { + dest_len = 1; + _ = src_ptr78[3..][0..dest_len :1]; +} +const src_mem43: [2]u8 = .{ 0, 0 }; +const src_ptr79: *const [1:0]u8 = src_mem43[0..1 :0]; +comptime { + _ = src_ptr79[0..3]; +} +comptime { + _ = src_ptr79[0..][0..3]; +} +comptime { + _ = src_ptr79[1..3]; +} +comptime { + _ = src_ptr79[1..][0..2]; +} +comptime { + _ = src_ptr79[1..][0..3]; +} +comptime { + _ = src_ptr79[3..]; +} +comptime { + _ = src_ptr79[3..2]; +} +comptime { + _ = src_ptr79[3..3]; +} +comptime { + _ = src_ptr79[3..1]; +} +export fn fn1595() void { + dest_end = 3; + _ = src_ptr79[3..dest_end]; +} +export fn fn1596() void { + dest_end = 1; + _ = src_ptr79[3..dest_end]; +} +comptime { + _ = src_ptr79[3..][0..2]; +} +comptime { + _ = src_ptr79[3..][0..3]; +} +comptime { + _ = src_ptr79[3..][0..1]; +} +export fn fn1597() void { + dest_len = 3; + _ = src_ptr79[3..][0..dest_len]; +} +export fn fn1598() void { + dest_len = 1; + _ = src_ptr79[3..][0..dest_len]; +} +comptime { + _ = src_ptr79[0.. :1]; +} +comptime { + _ = src_ptr79[0..2 :1]; +} +comptime { + _ = src_ptr79[0..3 :1]; +} +comptime { + _ = src_ptr79[0..1 :1]; +} +comptime { + _ = src_ptr79[0..][0..2 :1]; +} +comptime { + _ = src_ptr79[0..][0..3 :1]; +} +comptime { + _ = src_ptr79[0..][0..1 :1]; +} +comptime { + _ = src_ptr79[1.. :1]; +} +comptime { + _ = src_ptr79[1..2 :1]; +} +comptime { + _ = src_ptr79[1..3 :1]; +} +comptime { + _ = src_ptr79[1..1 :1]; +} +comptime { + _ = src_ptr79[1..][0..2 :1]; +} +comptime { + _ = src_ptr79[1..][0..3 :1]; +} +comptime { + _ = src_ptr79[1..][0..1 :1]; +} +comptime { + _ = src_ptr79[3.. :1]; +} +comptime { + _ = src_ptr79[3..2 :1]; +} +comptime { + _ = src_ptr79[3..3 :1]; +} +comptime { + _ = src_ptr79[3..1 :1]; +} +export fn fn1599() void { + dest_end = 3; + _ = src_ptr79[3..dest_end :1]; +} +export fn fn1600() void { + dest_end = 1; + _ = src_ptr79[3..dest_end :1]; +} +comptime { + _ = src_ptr79[3..][0..2 :1]; +} +comptime { + _ = src_ptr79[3..][0..3 :1]; +} +comptime { + _ = src_ptr79[3..][0..1 :1]; +} +export fn fn1601() void { + dest_len = 3; + _ = src_ptr79[3..][0..dest_len :1]; +} +export fn fn1602() void { + dest_len = 1; + _ = src_ptr79[3..][0..dest_len :1]; +} +const src_mem44: [3]u8 = .{ 0, 0, 0 }; +const src_ptr80: *const [3]u8 = src_mem44[0..3]; +comptime { + _ = src_ptr80[1..][0..3]; +} +comptime { + _ = src_ptr80[3..2]; +} +comptime { + _ = src_ptr80[3..1]; +} +comptime { + _ = src_ptr80[3..][0..2]; +} +comptime { + _ = src_ptr80[3..][0..3]; +} +comptime { + _ = src_ptr80[3..][0..1]; +} +comptime { + _ = src_ptr80[0.. :1]; +} +comptime { + _ = src_ptr80[0..2 :1]; +} +comptime { + _ = src_ptr80[0..3 :1]; +} +comptime { + _ = src_ptr80[0..1 :1]; +} +comptime { + _ = src_ptr80[0..][0..2 :1]; +} +comptime { + _ = src_ptr80[0..][0..3 :1]; +} +comptime { + _ = src_ptr80[0..][0..1 :1]; +} +comptime { + _ = src_ptr80[1.. :1]; +} +comptime { + _ = src_ptr80[1..2 :1]; +} +comptime { + _ = src_ptr80[1..3 :1]; +} +comptime { + _ = src_ptr80[1..1 :1]; +} +comptime { + _ = src_ptr80[1..][0..2 :1]; +} +comptime { + _ = src_ptr80[1..][0..3 :1]; +} +comptime { + _ = src_ptr80[1..][0..1 :1]; +} +comptime { + _ = src_ptr80[3.. :1]; +} +comptime { + _ = src_ptr80[3..2 :1]; +} +comptime { + _ = src_ptr80[3..3 :1]; +} +comptime { + _ = src_ptr80[3..1 :1]; +} +export fn fn1603() void { + dest_end = 3; + _ = src_ptr80[3..dest_end :1]; +} +export fn fn1604() void { + dest_end = 1; + _ = src_ptr80[3..dest_end :1]; +} +comptime { + _ = src_ptr80[3..][0..2 :1]; +} +comptime { + _ = src_ptr80[3..][0..3 :1]; +} +comptime { + _ = src_ptr80[3..][0..1 :1]; +} +export fn fn1605() void { + dest_len = 3; + _ = src_ptr80[3..][0..dest_len :1]; +} +export fn fn1606() void { + dest_len = 1; + _ = src_ptr80[3..][0..dest_len :1]; +} +const src_mem45: [3]u8 = .{ 0, 0, 0 }; +const src_ptr81: *const [2:0]u8 = src_mem45[0..2 :0]; +comptime { + _ = src_ptr81[1..][0..3]; +} +comptime { + _ = src_ptr81[3..]; +} +comptime { + _ = src_ptr81[3..2]; +} +comptime { + _ = src_ptr81[3..1]; +} +comptime { + _ = src_ptr81[3..][0..2]; +} +comptime { + _ = src_ptr81[3..][0..3]; +} +comptime { + _ = src_ptr81[3..][0..1]; +} +comptime { + _ = src_ptr81[0.. :1]; +} +comptime { + _ = src_ptr81[0..2 :1]; +} +comptime { + _ = src_ptr81[0..3 :1]; +} +comptime { + _ = src_ptr81[0..1 :1]; +} +comptime { + _ = src_ptr81[0..][0..2 :1]; +} +comptime { + _ = src_ptr81[0..][0..3 :1]; +} +comptime { + _ = src_ptr81[0..][0..1 :1]; +} +comptime { + _ = src_ptr81[1.. :1]; +} +comptime { + _ = src_ptr81[1..2 :1]; +} +comptime { + _ = src_ptr81[1..3 :1]; +} +comptime { + _ = src_ptr81[1..1 :1]; +} +comptime { + _ = src_ptr81[1..][0..2 :1]; +} +comptime { + _ = src_ptr81[1..][0..3 :1]; +} +comptime { + _ = src_ptr81[1..][0..1 :1]; +} +comptime { + _ = src_ptr81[3.. :1]; +} +comptime { + _ = src_ptr81[3..2 :1]; +} +comptime { + _ = src_ptr81[3..3 :1]; +} +comptime { + _ = src_ptr81[3..1 :1]; +} +export fn fn1607() void { + dest_end = 3; + _ = src_ptr81[3..dest_end :1]; +} +export fn fn1608() void { + dest_end = 1; + _ = src_ptr81[3..dest_end :1]; +} +comptime { + _ = src_ptr81[3..][0..2 :1]; +} +comptime { + _ = src_ptr81[3..][0..3 :1]; +} +comptime { + _ = src_ptr81[3..][0..1 :1]; +} +export fn fn1609() void { + dest_len = 3; + _ = src_ptr81[3..][0..dest_len :1]; +} +export fn fn1610() void { + dest_len = 1; + _ = src_ptr81[3..][0..dest_len :1]; +} +const src_mem46: [1]u8 = .{0}; +const src_ptr82: *const [1]u8 = src_mem46[0..1]; +comptime { + _ = src_ptr82[0..2]; +} +comptime { + _ = src_ptr82[0..3]; +} +comptime { + _ = src_ptr82[0..][0..2]; +} +comptime { + _ = src_ptr82[0..][0..3]; +} +comptime { + _ = src_ptr82[1..2]; +} +comptime { + _ = src_ptr82[1..3]; +} +comptime { + _ = src_ptr82[1..][0..2]; +} +comptime { + _ = src_ptr82[1..][0..3]; +} +comptime { + _ = src_ptr82[1..][0..1]; +} +comptime { + _ = src_ptr82[3..]; +} +comptime { + _ = src_ptr82[3..2]; +} +comptime { + _ = src_ptr82[3..3]; +} +comptime { + _ = src_ptr82[3..1]; +} +export fn fn1611() void { + dest_end = 3; + _ = src_ptr82[3..dest_end]; +} +export fn fn1612() void { + dest_end = 1; + _ = src_ptr82[3..dest_end]; +} +comptime { + _ = src_ptr82[3..][0..2]; +} +comptime { + _ = src_ptr82[3..][0..3]; +} +comptime { + _ = src_ptr82[3..][0..1]; +} +export fn fn1613() void { + dest_len = 3; + _ = src_ptr82[3..][0..dest_len]; +} +export fn fn1614() void { + dest_len = 1; + _ = src_ptr82[3..][0..dest_len]; +} +comptime { + _ = src_ptr82[0.. :1]; +} +comptime { + _ = src_ptr82[0..2 :1]; +} +comptime { + _ = src_ptr82[0..3 :1]; +} +comptime { + _ = src_ptr82[0..1 :1]; +} +comptime { + _ = src_ptr82[0..][0..2 :1]; +} +comptime { + _ = src_ptr82[0..][0..3 :1]; +} +comptime { + _ = src_ptr82[0..][0..1 :1]; +} +comptime { + _ = src_ptr82[1.. :1]; +} +comptime { + _ = src_ptr82[1..2 :1]; +} +comptime { + _ = src_ptr82[1..3 :1]; +} +comptime { + _ = src_ptr82[1..1 :1]; +} +export fn fn1615() void { + dest_end = 3; + _ = src_ptr82[1..dest_end :1]; +} +export fn fn1616() void { + dest_end = 1; + _ = src_ptr82[1..dest_end :1]; +} +comptime { + _ = src_ptr82[1..][0..2 :1]; +} +comptime { + _ = src_ptr82[1..][0..3 :1]; +} +comptime { + _ = src_ptr82[1..][0..1 :1]; +} +export fn fn1617() void { + dest_len = 3; + _ = src_ptr82[1..][0..dest_len :1]; +} +export fn fn1618() void { + dest_len = 1; + _ = src_ptr82[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr82[3.. :1]; +} +comptime { + _ = src_ptr82[3..2 :1]; +} +comptime { + _ = src_ptr82[3..3 :1]; +} +comptime { + _ = src_ptr82[3..1 :1]; +} +export fn fn1619() void { + dest_end = 3; + _ = src_ptr82[3..dest_end :1]; +} +export fn fn1620() void { + dest_end = 1; + _ = src_ptr82[3..dest_end :1]; +} +comptime { + _ = src_ptr82[3..][0..2 :1]; +} +comptime { + _ = src_ptr82[3..][0..3 :1]; +} +comptime { + _ = src_ptr82[3..][0..1 :1]; +} +export fn fn1621() void { + dest_len = 3; + _ = src_ptr82[3..][0..dest_len :1]; +} +export fn fn1622() void { + dest_len = 1; + _ = src_ptr82[3..][0..dest_len :1]; +} +const src_mem47: [1]u8 = .{0}; +const src_ptr83: *const [0:0]u8 = src_mem47[0..0 :0]; +comptime { + _ = src_ptr83[0..2]; +} +comptime { + _ = src_ptr83[0..3]; +} +comptime { + _ = src_ptr83[0..][0..2]; +} +comptime { + _ = src_ptr83[0..][0..3]; +} +comptime { + _ = src_ptr83[1..]; +} +comptime { + _ = src_ptr83[1..2]; +} +comptime { + _ = src_ptr83[1..3]; +} +comptime { + _ = src_ptr83[1..][0..2]; +} +comptime { + _ = src_ptr83[1..][0..3]; +} +comptime { + _ = src_ptr83[1..][0..1]; +} +comptime { + _ = src_ptr83[3..]; +} +comptime { + _ = src_ptr83[3..2]; +} +comptime { + _ = src_ptr83[3..3]; +} +comptime { + _ = src_ptr83[3..1]; +} +export fn fn1623() void { + dest_end = 3; + _ = src_ptr83[3..dest_end]; +} +export fn fn1624() void { + dest_end = 1; + _ = src_ptr83[3..dest_end]; +} +comptime { + _ = src_ptr83[3..][0..2]; +} +comptime { + _ = src_ptr83[3..][0..3]; +} +comptime { + _ = src_ptr83[3..][0..1]; +} +export fn fn1625() void { + dest_len = 3; + _ = src_ptr83[3..][0..dest_len]; +} +export fn fn1626() void { + dest_len = 1; + _ = src_ptr83[3..][0..dest_len]; +} +comptime { + _ = src_ptr83[0.. :1]; +} +comptime { + _ = src_ptr83[0..2 :1]; +} +comptime { + _ = src_ptr83[0..3 :1]; +} +comptime { + _ = src_ptr83[0..1 :1]; +} +comptime { + _ = src_ptr83[0..][0..2 :1]; +} +comptime { + _ = src_ptr83[0..][0..3 :1]; +} +comptime { + _ = src_ptr83[0..][0..1 :1]; +} +comptime { + _ = src_ptr83[1.. :1]; +} +comptime { + _ = src_ptr83[1..2 :1]; +} +comptime { + _ = src_ptr83[1..3 :1]; +} +comptime { + _ = src_ptr83[1..1 :1]; +} +export fn fn1627() void { + dest_end = 3; + _ = src_ptr83[1..dest_end :1]; +} +export fn fn1628() void { + dest_end = 1; + _ = src_ptr83[1..dest_end :1]; +} +comptime { + _ = src_ptr83[1..][0..2 :1]; +} +comptime { + _ = src_ptr83[1..][0..3 :1]; +} +comptime { + _ = src_ptr83[1..][0..1 :1]; +} +export fn fn1629() void { + dest_len = 3; + _ = src_ptr83[1..][0..dest_len :1]; +} +export fn fn1630() void { + dest_len = 1; + _ = src_ptr83[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr83[3.. :1]; +} +comptime { + _ = src_ptr83[3..2 :1]; +} +comptime { + _ = src_ptr83[3..3 :1]; +} +comptime { + _ = src_ptr83[3..1 :1]; +} +export fn fn1631() void { + dest_end = 3; + _ = src_ptr83[3..dest_end :1]; +} +export fn fn1632() void { + dest_end = 1; + _ = src_ptr83[3..dest_end :1]; +} +comptime { + _ = src_ptr83[3..][0..2 :1]; +} +comptime { + _ = src_ptr83[3..][0..3 :1]; +} +comptime { + _ = src_ptr83[3..][0..1 :1]; +} +export fn fn1633() void { + dest_len = 3; + _ = src_ptr83[3..][0..dest_len :1]; +} +export fn fn1634() void { + dest_len = 1; + _ = src_ptr83[3..][0..dest_len :1]; +} +const src_mem48: [2]u8 = .{ 0, 0 }; +var src_ptr84: *const [2]u8 = src_mem48[0..2]; +export fn fn1635() void { + _ = src_ptr84[0..3]; +} +export fn fn1636() void { + _ = src_ptr84[0..][0..3]; +} +export fn fn1637() void { + _ = src_ptr84[1..3]; +} +export fn fn1638() void { + _ = src_ptr84[1..][0..2]; +} +export fn fn1639() void { + _ = src_ptr84[1..][0..3]; +} +export fn fn1640() void { + _ = src_ptr84[3..]; +} +export fn fn1641() void { + _ = src_ptr84[3..2]; +} +export fn fn1642() void { + _ = src_ptr84[3..3]; +} +export fn fn1643() void { + _ = src_ptr84[3..1]; +} +export fn fn1644() void { + dest_end = 3; + _ = src_ptr84[3..dest_end]; +} +export fn fn1645() void { + dest_end = 1; + _ = src_ptr84[3..dest_end]; +} +export fn fn1646() void { + _ = src_ptr84[3..][0..2]; +} +export fn fn1647() void { + _ = src_ptr84[3..][0..3]; +} +export fn fn1648() void { + _ = src_ptr84[3..][0..1]; +} +export fn fn1649() void { + dest_len = 3; + _ = src_ptr84[3..][0..dest_len]; +} +export fn fn1650() void { + dest_len = 1; + _ = src_ptr84[3..][0..dest_len]; +} +export fn fn1651() void { + _ = src_ptr84[0.. :1]; +} +export fn fn1652() void { + _ = src_ptr84[0..2 :1]; +} +export fn fn1653() void { + _ = src_ptr84[0..3 :1]; +} +export fn fn1654() void { + _ = src_ptr84[0..][0..2 :1]; +} +export fn fn1655() void { + _ = src_ptr84[0..][0..3 :1]; +} +export fn fn1656() void { + _ = src_ptr84[1.. :1]; +} +export fn fn1657() void { + _ = src_ptr84[1..2 :1]; +} +export fn fn1658() void { + _ = src_ptr84[1..3 :1]; +} +export fn fn1659() void { + _ = src_ptr84[1..][0..2 :1]; +} +export fn fn1660() void { + _ = src_ptr84[1..][0..3 :1]; +} +export fn fn1661() void { + _ = src_ptr84[1..][0..1 :1]; +} +export fn fn1662() void { + _ = src_ptr84[3.. :1]; +} +export fn fn1663() void { + _ = src_ptr84[3..2 :1]; +} +export fn fn1664() void { + _ = src_ptr84[3..3 :1]; +} +export fn fn1665() void { + _ = src_ptr84[3..1 :1]; +} +export fn fn1666() void { + dest_end = 3; + _ = src_ptr84[3..dest_end :1]; +} +export fn fn1667() void { + dest_end = 1; + _ = src_ptr84[3..dest_end :1]; +} +export fn fn1668() void { + _ = src_ptr84[3..][0..2 :1]; +} +export fn fn1669() void { + _ = src_ptr84[3..][0..3 :1]; +} +export fn fn1670() void { + _ = src_ptr84[3..][0..1 :1]; +} +export fn fn1671() void { + dest_len = 3; + _ = src_ptr84[3..][0..dest_len :1]; +} +export fn fn1672() void { + dest_len = 1; + _ = src_ptr84[3..][0..dest_len :1]; +} +const src_mem49: [2]u8 = .{ 0, 0 }; +var src_ptr85: *const [1:0]u8 = src_mem49[0..1 :0]; +export fn fn1673() void { + _ = src_ptr85[0..3]; +} +export fn fn1674() void { + _ = src_ptr85[0..][0..3]; +} +export fn fn1675() void { + _ = src_ptr85[1..3]; +} +export fn fn1676() void { + _ = src_ptr85[1..][0..2]; +} +export fn fn1677() void { + _ = src_ptr85[1..][0..3]; +} +export fn fn1678() void { + _ = src_ptr85[3..]; +} +export fn fn1679() void { + _ = src_ptr85[3..2]; +} +export fn fn1680() void { + _ = src_ptr85[3..3]; +} +export fn fn1681() void { + _ = src_ptr85[3..1]; +} +export fn fn1682() void { + dest_end = 3; + _ = src_ptr85[3..dest_end]; +} +export fn fn1683() void { + dest_end = 1; + _ = src_ptr85[3..dest_end]; +} +export fn fn1684() void { + _ = src_ptr85[3..][0..2]; +} +export fn fn1685() void { + _ = src_ptr85[3..][0..3]; +} +export fn fn1686() void { + _ = src_ptr85[3..][0..1]; +} +export fn fn1687() void { + dest_len = 3; + _ = src_ptr85[3..][0..dest_len]; +} +export fn fn1688() void { + dest_len = 1; + _ = src_ptr85[3..][0..dest_len]; +} +export fn fn1689() void { + _ = src_ptr85[0..2 :1]; +} +export fn fn1690() void { + _ = src_ptr85[0..3 :1]; +} +export fn fn1691() void { + _ = src_ptr85[0..][0..2 :1]; +} +export fn fn1692() void { + _ = src_ptr85[0..][0..3 :1]; +} +export fn fn1693() void { + _ = src_ptr85[1..2 :1]; +} +export fn fn1694() void { + _ = src_ptr85[1..3 :1]; +} +export fn fn1695() void { + _ = src_ptr85[1..][0..2 :1]; +} +export fn fn1696() void { + _ = src_ptr85[1..][0..3 :1]; +} +export fn fn1697() void { + _ = src_ptr85[1..][0..1 :1]; +} +export fn fn1698() void { + _ = src_ptr85[3.. :1]; +} +export fn fn1699() void { + _ = src_ptr85[3..2 :1]; +} +export fn fn1700() void { + _ = src_ptr85[3..3 :1]; +} +export fn fn1701() void { + _ = src_ptr85[3..1 :1]; +} +export fn fn1702() void { + dest_end = 3; + _ = src_ptr85[3..dest_end :1]; +} +export fn fn1703() void { + dest_end = 1; + _ = src_ptr85[3..dest_end :1]; +} +export fn fn1704() void { + _ = src_ptr85[3..][0..2 :1]; +} +export fn fn1705() void { + _ = src_ptr85[3..][0..3 :1]; +} +export fn fn1706() void { + _ = src_ptr85[3..][0..1 :1]; +} +export fn fn1707() void { + dest_len = 3; + _ = src_ptr85[3..][0..dest_len :1]; +} +export fn fn1708() void { + dest_len = 1; + _ = src_ptr85[3..][0..dest_len :1]; +} +const src_mem50: [3]u8 = .{ 0, 0, 0 }; +var src_ptr86: *const [3]u8 = src_mem50[0..3]; +export fn fn1709() void { + _ = src_ptr86[1..][0..3]; +} +export fn fn1710() void { + _ = src_ptr86[3..2]; +} +export fn fn1711() void { + _ = src_ptr86[3..1]; +} +export fn fn1712() void { + _ = src_ptr86[3..][0..2]; +} +export fn fn1713() void { + _ = src_ptr86[3..][0..3]; +} +export fn fn1714() void { + _ = src_ptr86[3..][0..1]; +} +export fn fn1715() void { + _ = src_ptr86[0.. :1]; +} +export fn fn1716() void { + _ = src_ptr86[0..3 :1]; +} +export fn fn1717() void { + _ = src_ptr86[0..][0..3 :1]; +} +export fn fn1718() void { + _ = src_ptr86[1.. :1]; +} +export fn fn1719() void { + _ = src_ptr86[1..3 :1]; +} +export fn fn1720() void { + _ = src_ptr86[1..][0..2 :1]; +} +export fn fn1721() void { + _ = src_ptr86[1..][0..3 :1]; +} +export fn fn1722() void { + _ = src_ptr86[3.. :1]; +} +export fn fn1723() void { + _ = src_ptr86[3..2 :1]; +} +export fn fn1724() void { + _ = src_ptr86[3..3 :1]; +} +export fn fn1725() void { + _ = src_ptr86[3..1 :1]; +} +export fn fn1726() void { + dest_end = 3; + _ = src_ptr86[3..dest_end :1]; +} +export fn fn1727() void { + dest_end = 1; + _ = src_ptr86[3..dest_end :1]; +} +export fn fn1728() void { + _ = src_ptr86[3..][0..2 :1]; +} +export fn fn1729() void { + _ = src_ptr86[3..][0..3 :1]; +} +export fn fn1730() void { + _ = src_ptr86[3..][0..1 :1]; +} +export fn fn1731() void { + dest_len = 3; + _ = src_ptr86[3..][0..dest_len :1]; +} +export fn fn1732() void { + dest_len = 1; + _ = src_ptr86[3..][0..dest_len :1]; +} +const src_mem51: [3]u8 = .{ 0, 0, 0 }; +var src_ptr87: *const [2:0]u8 = src_mem51[0..2 :0]; +export fn fn1733() void { + _ = src_ptr87[1..][0..3]; +} +export fn fn1734() void { + _ = src_ptr87[3..]; +} +export fn fn1735() void { + _ = src_ptr87[3..2]; +} +export fn fn1736() void { + _ = src_ptr87[3..1]; +} +export fn fn1737() void { + _ = src_ptr87[3..][0..2]; +} +export fn fn1738() void { + _ = src_ptr87[3..][0..3]; +} +export fn fn1739() void { + _ = src_ptr87[3..][0..1]; +} +export fn fn1740() void { + _ = src_ptr87[0..3 :1]; +} +export fn fn1741() void { + _ = src_ptr87[0..][0..3 :1]; +} +export fn fn1742() void { + _ = src_ptr87[1..3 :1]; +} +export fn fn1743() void { + _ = src_ptr87[1..][0..2 :1]; +} +export fn fn1744() void { + _ = src_ptr87[1..][0..3 :1]; +} +export fn fn1745() void { + _ = src_ptr87[3.. :1]; +} +export fn fn1746() void { + _ = src_ptr87[3..2 :1]; +} +export fn fn1747() void { + _ = src_ptr87[3..3 :1]; +} +export fn fn1748() void { + _ = src_ptr87[3..1 :1]; +} +export fn fn1749() void { + dest_end = 3; + _ = src_ptr87[3..dest_end :1]; +} +export fn fn1750() void { + dest_end = 1; + _ = src_ptr87[3..dest_end :1]; +} +export fn fn1751() void { + _ = src_ptr87[3..][0..2 :1]; +} +export fn fn1752() void { + _ = src_ptr87[3..][0..3 :1]; +} +export fn fn1753() void { + _ = src_ptr87[3..][0..1 :1]; +} +export fn fn1754() void { + dest_len = 3; + _ = src_ptr87[3..][0..dest_len :1]; +} +export fn fn1755() void { + dest_len = 1; + _ = src_ptr87[3..][0..dest_len :1]; +} +const src_mem52: [1]u8 = .{0}; +var src_ptr88: *const [1]u8 = src_mem52[0..1]; +export fn fn1756() void { + _ = src_ptr88[0..2]; +} +export fn fn1757() void { + _ = src_ptr88[0..3]; +} +export fn fn1758() void { + _ = src_ptr88[0..][0..2]; +} +export fn fn1759() void { + _ = src_ptr88[0..][0..3]; +} +export fn fn1760() void { + _ = src_ptr88[1..2]; +} +export fn fn1761() void { + _ = src_ptr88[1..3]; +} +export fn fn1762() void { + _ = src_ptr88[1..][0..2]; +} +export fn fn1763() void { + _ = src_ptr88[1..][0..3]; +} +export fn fn1764() void { + _ = src_ptr88[1..][0..1]; +} +export fn fn1765() void { + _ = src_ptr88[3..]; +} +export fn fn1766() void { + _ = src_ptr88[3..2]; +} +export fn fn1767() void { + _ = src_ptr88[3..3]; +} +export fn fn1768() void { + _ = src_ptr88[3..1]; +} +export fn fn1769() void { + dest_end = 3; + _ = src_ptr88[3..dest_end]; +} +export fn fn1770() void { + dest_end = 1; + _ = src_ptr88[3..dest_end]; +} +export fn fn1771() void { + _ = src_ptr88[3..][0..2]; +} +export fn fn1772() void { + _ = src_ptr88[3..][0..3]; +} +export fn fn1773() void { + _ = src_ptr88[3..][0..1]; +} +export fn fn1774() void { + dest_len = 3; + _ = src_ptr88[3..][0..dest_len]; +} +export fn fn1775() void { + dest_len = 1; + _ = src_ptr88[3..][0..dest_len]; +} +export fn fn1776() void { + _ = src_ptr88[0.. :1]; +} +export fn fn1777() void { + _ = src_ptr88[0..2 :1]; +} +export fn fn1778() void { + _ = src_ptr88[0..3 :1]; +} +export fn fn1779() void { + _ = src_ptr88[0..1 :1]; +} +export fn fn1780() void { + _ = src_ptr88[0..][0..2 :1]; +} +export fn fn1781() void { + _ = src_ptr88[0..][0..3 :1]; +} +export fn fn1782() void { + _ = src_ptr88[0..][0..1 :1]; +} +export fn fn1783() void { + _ = src_ptr88[1.. :1]; +} +export fn fn1784() void { + _ = src_ptr88[1..2 :1]; +} +export fn fn1785() void { + _ = src_ptr88[1..3 :1]; +} +export fn fn1786() void { + _ = src_ptr88[1..1 :1]; +} +export fn fn1787() void { + dest_end = 3; + _ = src_ptr88[1..dest_end :1]; +} +export fn fn1788() void { + dest_end = 1; + _ = src_ptr88[1..dest_end :1]; +} +export fn fn1789() void { + _ = src_ptr88[1..][0..2 :1]; +} +export fn fn1790() void { + _ = src_ptr88[1..][0..3 :1]; +} +export fn fn1791() void { + _ = src_ptr88[1..][0..1 :1]; +} +export fn fn1792() void { + dest_len = 3; + _ = src_ptr88[1..][0..dest_len :1]; +} +export fn fn1793() void { + dest_len = 1; + _ = src_ptr88[1..][0..dest_len :1]; +} +export fn fn1794() void { + _ = src_ptr88[3.. :1]; +} +export fn fn1795() void { + _ = src_ptr88[3..2 :1]; +} +export fn fn1796() void { + _ = src_ptr88[3..3 :1]; +} +export fn fn1797() void { + _ = src_ptr88[3..1 :1]; +} +export fn fn1798() void { + dest_end = 3; + _ = src_ptr88[3..dest_end :1]; +} +export fn fn1799() void { + dest_end = 1; + _ = src_ptr88[3..dest_end :1]; +} +export fn fn1800() void { + _ = src_ptr88[3..][0..2 :1]; +} +export fn fn1801() void { + _ = src_ptr88[3..][0..3 :1]; +} +export fn fn1802() void { + _ = src_ptr88[3..][0..1 :1]; +} +export fn fn1803() void { + dest_len = 3; + _ = src_ptr88[3..][0..dest_len :1]; +} +export fn fn1804() void { + dest_len = 1; + _ = src_ptr88[3..][0..dest_len :1]; +} +const src_mem53: [1]u8 = .{0}; +var src_ptr89: *const [0:0]u8 = src_mem53[0..0 :0]; +export fn fn1805() void { + _ = src_ptr89[0..2]; +} +export fn fn1806() void { + _ = src_ptr89[0..3]; +} +export fn fn1807() void { + _ = src_ptr89[0..][0..2]; +} +export fn fn1808() void { + _ = src_ptr89[0..][0..3]; +} +export fn fn1809() void { + _ = src_ptr89[1..]; +} +export fn fn1810() void { + _ = src_ptr89[1..2]; +} +export fn fn1811() void { + _ = src_ptr89[1..3]; +} +export fn fn1812() void { + _ = src_ptr89[1..][0..2]; +} +export fn fn1813() void { + _ = src_ptr89[1..][0..3]; +} +export fn fn1814() void { + _ = src_ptr89[1..][0..1]; +} +export fn fn1815() void { + _ = src_ptr89[3..]; +} +export fn fn1816() void { + _ = src_ptr89[3..2]; +} +export fn fn1817() void { + _ = src_ptr89[3..3]; +} +export fn fn1818() void { + _ = src_ptr89[3..1]; +} +export fn fn1819() void { + dest_end = 3; + _ = src_ptr89[3..dest_end]; +} +export fn fn1820() void { + dest_end = 1; + _ = src_ptr89[3..dest_end]; +} +export fn fn1821() void { + _ = src_ptr89[3..][0..2]; +} +export fn fn1822() void { + _ = src_ptr89[3..][0..3]; +} +export fn fn1823() void { + _ = src_ptr89[3..][0..1]; +} +export fn fn1824() void { + dest_len = 3; + _ = src_ptr89[3..][0..dest_len]; +} +export fn fn1825() void { + dest_len = 1; + _ = src_ptr89[3..][0..dest_len]; +} +export fn fn1826() void { + _ = src_ptr89[0..2 :1]; +} +export fn fn1827() void { + _ = src_ptr89[0..3 :1]; +} +export fn fn1828() void { + _ = src_ptr89[0..1 :1]; +} +export fn fn1829() void { + _ = src_ptr89[0..][0..2 :1]; +} +export fn fn1830() void { + _ = src_ptr89[0..][0..3 :1]; +} +export fn fn1831() void { + _ = src_ptr89[0..][0..1 :1]; +} +export fn fn1832() void { + _ = src_ptr89[1.. :1]; +} +export fn fn1833() void { + _ = src_ptr89[1..2 :1]; +} +export fn fn1834() void { + _ = src_ptr89[1..3 :1]; +} +export fn fn1835() void { + _ = src_ptr89[1..1 :1]; +} +export fn fn1836() void { + dest_end = 3; + _ = src_ptr89[1..dest_end :1]; +} +export fn fn1837() void { + dest_end = 1; + _ = src_ptr89[1..dest_end :1]; +} +export fn fn1838() void { + _ = src_ptr89[1..][0..2 :1]; +} +export fn fn1839() void { + _ = src_ptr89[1..][0..3 :1]; +} +export fn fn1840() void { + _ = src_ptr89[1..][0..1 :1]; +} +export fn fn1841() void { + dest_len = 3; + _ = src_ptr89[1..][0..dest_len :1]; +} +export fn fn1842() void { + dest_len = 1; + _ = src_ptr89[1..][0..dest_len :1]; +} +export fn fn1843() void { + _ = src_ptr89[3.. :1]; +} +export fn fn1844() void { + _ = src_ptr89[3..2 :1]; +} +export fn fn1845() void { + _ = src_ptr89[3..3 :1]; +} +export fn fn1846() void { + _ = src_ptr89[3..1 :1]; +} +export fn fn1847() void { + dest_end = 3; + _ = src_ptr89[3..dest_end :1]; +} +export fn fn1848() void { + dest_end = 1; + _ = src_ptr89[3..dest_end :1]; +} +export fn fn1849() void { + _ = src_ptr89[3..][0..2 :1]; +} +export fn fn1850() void { + _ = src_ptr89[3..][0..3 :1]; +} +export fn fn1851() void { + _ = src_ptr89[3..][0..1 :1]; +} +export fn fn1852() void { + dest_len = 3; + _ = src_ptr89[3..][0..dest_len :1]; +} +export fn fn1853() void { + dest_len = 1; + _ = src_ptr89[3..][0..dest_len :1]; +} +const src_mem54: [2]u8 = .{ 0, 0 }; +const src_ptr90: []const u8 = src_mem54[0..2]; +comptime { + _ = src_ptr90[0..3]; +} +comptime { + _ = src_ptr90[0..][0..3]; +} +comptime { + _ = src_ptr90[1..3]; +} +comptime { + _ = src_ptr90[1..][0..2]; +} +comptime { + _ = src_ptr90[1..][0..3]; +} +comptime { + _ = src_ptr90[3..]; +} +comptime { + _ = src_ptr90[3..2]; +} +comptime { + _ = src_ptr90[3..3]; +} +comptime { + _ = src_ptr90[3..1]; +} +export fn fn1854() void { + dest_end = 3; + _ = src_ptr90[3..dest_end]; +} +export fn fn1855() void { + dest_end = 1; + _ = src_ptr90[3..dest_end]; +} +comptime { + _ = src_ptr90[3..][0..2]; +} +comptime { + _ = src_ptr90[3..][0..3]; +} +comptime { + _ = src_ptr90[3..][0..1]; +} +export fn fn1856() void { + dest_len = 3; + _ = src_ptr90[3..][0..dest_len]; +} +export fn fn1857() void { + dest_len = 1; + _ = src_ptr90[3..][0..dest_len]; +} +comptime { + _ = src_ptr90[0.. :1]; +} +comptime { + _ = src_ptr90[0..2 :1]; +} +comptime { + _ = src_ptr90[0..3 :1]; +} +comptime { + _ = src_ptr90[0..1 :1]; +} +comptime { + _ = src_ptr90[0..][0..2 :1]; +} +comptime { + _ = src_ptr90[0..][0..3 :1]; +} +comptime { + _ = src_ptr90[0..][0..1 :1]; +} +comptime { + _ = src_ptr90[1.. :1]; +} +comptime { + _ = src_ptr90[1..2 :1]; +} +comptime { + _ = src_ptr90[1..3 :1]; +} +comptime { + _ = src_ptr90[1..1 :1]; +} +comptime { + _ = src_ptr90[1..][0..2 :1]; +} +comptime { + _ = src_ptr90[1..][0..3 :1]; +} +comptime { + _ = src_ptr90[1..][0..1 :1]; +} +comptime { + _ = src_ptr90[3.. :1]; +} +comptime { + _ = src_ptr90[3..2 :1]; +} +comptime { + _ = src_ptr90[3..3 :1]; +} +comptime { + _ = src_ptr90[3..1 :1]; +} +export fn fn1858() void { + dest_end = 3; + _ = src_ptr90[3..dest_end :1]; +} +export fn fn1859() void { + dest_end = 1; + _ = src_ptr90[3..dest_end :1]; +} +comptime { + _ = src_ptr90[3..][0..2 :1]; +} +comptime { + _ = src_ptr90[3..][0..3 :1]; +} +comptime { + _ = src_ptr90[3..][0..1 :1]; +} +export fn fn1860() void { + dest_len = 3; + _ = src_ptr90[3..][0..dest_len :1]; +} +export fn fn1861() void { + dest_len = 1; + _ = src_ptr90[3..][0..dest_len :1]; +} +const src_mem55: [2]u8 = .{ 0, 0 }; +const src_ptr91: [:0]const u8 = src_mem55[0..1 :0]; +comptime { + _ = src_ptr91[0..3]; +} +comptime { + _ = src_ptr91[0..][0..3]; +} +comptime { + _ = src_ptr91[1..3]; +} +comptime { + _ = src_ptr91[1..][0..2]; +} +comptime { + _ = src_ptr91[1..][0..3]; +} +comptime { + _ = src_ptr91[3..]; +} +comptime { + _ = src_ptr91[3..2]; +} +comptime { + _ = src_ptr91[3..3]; +} +comptime { + _ = src_ptr91[3..1]; +} +export fn fn1862() void { + dest_end = 3; + _ = src_ptr91[3..dest_end]; +} +export fn fn1863() void { + dest_end = 1; + _ = src_ptr91[3..dest_end]; +} +comptime { + _ = src_ptr91[3..][0..2]; +} +comptime { + _ = src_ptr91[3..][0..3]; +} +comptime { + _ = src_ptr91[3..][0..1]; +} +export fn fn1864() void { + dest_len = 3; + _ = src_ptr91[3..][0..dest_len]; +} +export fn fn1865() void { + dest_len = 1; + _ = src_ptr91[3..][0..dest_len]; +} +comptime { + _ = src_ptr91[0.. :1]; +} +comptime { + _ = src_ptr91[0..2 :1]; +} +comptime { + _ = src_ptr91[0..3 :1]; +} +comptime { + _ = src_ptr91[0..1 :1]; +} +comptime { + _ = src_ptr91[0..][0..2 :1]; +} +comptime { + _ = src_ptr91[0..][0..3 :1]; +} +comptime { + _ = src_ptr91[0..][0..1 :1]; +} +comptime { + _ = src_ptr91[1.. :1]; +} +comptime { + _ = src_ptr91[1..2 :1]; +} +comptime { + _ = src_ptr91[1..3 :1]; +} +comptime { + _ = src_ptr91[1..1 :1]; +} +comptime { + _ = src_ptr91[1..][0..2 :1]; +} +comptime { + _ = src_ptr91[1..][0..3 :1]; +} +comptime { + _ = src_ptr91[1..][0..1 :1]; +} +comptime { + _ = src_ptr91[3.. :1]; +} +comptime { + _ = src_ptr91[3..2 :1]; +} +comptime { + _ = src_ptr91[3..3 :1]; +} +comptime { + _ = src_ptr91[3..1 :1]; +} +export fn fn1866() void { + dest_end = 3; + _ = src_ptr91[3..dest_end :1]; +} +export fn fn1867() void { + dest_end = 1; + _ = src_ptr91[3..dest_end :1]; +} +comptime { + _ = src_ptr91[3..][0..2 :1]; +} +comptime { + _ = src_ptr91[3..][0..3 :1]; +} +comptime { + _ = src_ptr91[3..][0..1 :1]; +} +export fn fn1868() void { + dest_len = 3; + _ = src_ptr91[3..][0..dest_len :1]; +} +export fn fn1869() void { + dest_len = 1; + _ = src_ptr91[3..][0..dest_len :1]; +} +const src_mem56: [3]u8 = .{ 0, 0, 0 }; +const src_ptr92: []const u8 = src_mem56[0..3]; +comptime { + _ = src_ptr92[1..][0..3]; +} +comptime { + _ = src_ptr92[3..2]; +} +comptime { + _ = src_ptr92[3..1]; +} +comptime { + _ = src_ptr92[3..][0..2]; +} +comptime { + _ = src_ptr92[3..][0..3]; +} +comptime { + _ = src_ptr92[3..][0..1]; +} +comptime { + _ = src_ptr92[0.. :1]; +} +comptime { + _ = src_ptr92[0..2 :1]; +} +comptime { + _ = src_ptr92[0..3 :1]; +} +comptime { + _ = src_ptr92[0..1 :1]; +} +comptime { + _ = src_ptr92[0..][0..2 :1]; +} +comptime { + _ = src_ptr92[0..][0..3 :1]; +} +comptime { + _ = src_ptr92[0..][0..1 :1]; +} +comptime { + _ = src_ptr92[1.. :1]; +} +comptime { + _ = src_ptr92[1..2 :1]; +} +comptime { + _ = src_ptr92[1..3 :1]; +} +comptime { + _ = src_ptr92[1..1 :1]; +} +comptime { + _ = src_ptr92[1..][0..2 :1]; +} +comptime { + _ = src_ptr92[1..][0..3 :1]; +} +comptime { + _ = src_ptr92[1..][0..1 :1]; +} +comptime { + _ = src_ptr92[3.. :1]; +} +comptime { + _ = src_ptr92[3..2 :1]; +} +comptime { + _ = src_ptr92[3..3 :1]; +} +comptime { + _ = src_ptr92[3..1 :1]; +} +export fn fn1870() void { + dest_end = 3; + _ = src_ptr92[3..dest_end :1]; +} +export fn fn1871() void { + dest_end = 1; + _ = src_ptr92[3..dest_end :1]; +} +comptime { + _ = src_ptr92[3..][0..2 :1]; +} +comptime { + _ = src_ptr92[3..][0..3 :1]; +} +comptime { + _ = src_ptr92[3..][0..1 :1]; +} +export fn fn1872() void { + dest_len = 3; + _ = src_ptr92[3..][0..dest_len :1]; +} +export fn fn1873() void { + dest_len = 1; + _ = src_ptr92[3..][0..dest_len :1]; +} +const src_mem57: [3]u8 = .{ 0, 0, 0 }; +const src_ptr93: [:0]const u8 = src_mem57[0..2 :0]; +comptime { + _ = src_ptr93[1..][0..3]; +} +comptime { + _ = src_ptr93[3..]; +} +comptime { + _ = src_ptr93[3..2]; +} +comptime { + _ = src_ptr93[3..1]; +} +comptime { + _ = src_ptr93[3..][0..2]; +} +comptime { + _ = src_ptr93[3..][0..3]; +} +comptime { + _ = src_ptr93[3..][0..1]; +} +comptime { + _ = src_ptr93[0.. :1]; +} +comptime { + _ = src_ptr93[0..2 :1]; +} +comptime { + _ = src_ptr93[0..3 :1]; +} +comptime { + _ = src_ptr93[0..1 :1]; +} +comptime { + _ = src_ptr93[0..][0..2 :1]; +} +comptime { + _ = src_ptr93[0..][0..3 :1]; +} +comptime { + _ = src_ptr93[0..][0..1 :1]; +} +comptime { + _ = src_ptr93[1.. :1]; +} +comptime { + _ = src_ptr93[1..2 :1]; +} +comptime { + _ = src_ptr93[1..3 :1]; +} +comptime { + _ = src_ptr93[1..1 :1]; +} +comptime { + _ = src_ptr93[1..][0..2 :1]; +} +comptime { + _ = src_ptr93[1..][0..3 :1]; +} +comptime { + _ = src_ptr93[1..][0..1 :1]; +} +comptime { + _ = src_ptr93[3.. :1]; +} +comptime { + _ = src_ptr93[3..2 :1]; +} +comptime { + _ = src_ptr93[3..3 :1]; +} +comptime { + _ = src_ptr93[3..1 :1]; +} +export fn fn1874() void { + dest_end = 3; + _ = src_ptr93[3..dest_end :1]; +} +export fn fn1875() void { + dest_end = 1; + _ = src_ptr93[3..dest_end :1]; +} +comptime { + _ = src_ptr93[3..][0..2 :1]; +} +comptime { + _ = src_ptr93[3..][0..3 :1]; +} +comptime { + _ = src_ptr93[3..][0..1 :1]; +} +export fn fn1876() void { + dest_len = 3; + _ = src_ptr93[3..][0..dest_len :1]; +} +export fn fn1877() void { + dest_len = 1; + _ = src_ptr93[3..][0..dest_len :1]; +} +const src_mem58: [1]u8 = .{0}; +const src_ptr94: []const u8 = src_mem58[0..1]; +comptime { + _ = src_ptr94[0..2]; +} +comptime { + _ = src_ptr94[0..3]; +} +comptime { + _ = src_ptr94[0..][0..2]; +} +comptime { + _ = src_ptr94[0..][0..3]; +} +comptime { + _ = src_ptr94[1..2]; +} +comptime { + _ = src_ptr94[1..3]; +} +comptime { + _ = src_ptr94[1..][0..2]; +} +comptime { + _ = src_ptr94[1..][0..3]; +} +comptime { + _ = src_ptr94[1..][0..1]; +} +comptime { + _ = src_ptr94[3..]; +} +comptime { + _ = src_ptr94[3..2]; +} +comptime { + _ = src_ptr94[3..3]; +} +comptime { + _ = src_ptr94[3..1]; +} +export fn fn1878() void { + dest_end = 3; + _ = src_ptr94[3..dest_end]; +} +export fn fn1879() void { + dest_end = 1; + _ = src_ptr94[3..dest_end]; +} +comptime { + _ = src_ptr94[3..][0..2]; +} +comptime { + _ = src_ptr94[3..][0..3]; +} +comptime { + _ = src_ptr94[3..][0..1]; +} +export fn fn1880() void { + dest_len = 3; + _ = src_ptr94[3..][0..dest_len]; +} +export fn fn1881() void { + dest_len = 1; + _ = src_ptr94[3..][0..dest_len]; +} +comptime { + _ = src_ptr94[0.. :1]; +} +comptime { + _ = src_ptr94[0..2 :1]; +} +comptime { + _ = src_ptr94[0..3 :1]; +} +comptime { + _ = src_ptr94[0..1 :1]; +} +comptime { + _ = src_ptr94[0..][0..2 :1]; +} +comptime { + _ = src_ptr94[0..][0..3 :1]; +} +comptime { + _ = src_ptr94[0..][0..1 :1]; +} +comptime { + _ = src_ptr94[1.. :1]; +} +comptime { + _ = src_ptr94[1..2 :1]; +} +comptime { + _ = src_ptr94[1..3 :1]; +} +comptime { + _ = src_ptr94[1..1 :1]; +} +export fn fn1882() void { + dest_end = 3; + _ = src_ptr94[1..dest_end :1]; +} +export fn fn1883() void { + dest_end = 1; + _ = src_ptr94[1..dest_end :1]; +} +comptime { + _ = src_ptr94[1..][0..2 :1]; +} +comptime { + _ = src_ptr94[1..][0..3 :1]; +} +comptime { + _ = src_ptr94[1..][0..1 :1]; +} +export fn fn1884() void { + dest_len = 3; + _ = src_ptr94[1..][0..dest_len :1]; +} +export fn fn1885() void { + dest_len = 1; + _ = src_ptr94[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr94[3.. :1]; +} +comptime { + _ = src_ptr94[3..2 :1]; +} +comptime { + _ = src_ptr94[3..3 :1]; +} +comptime { + _ = src_ptr94[3..1 :1]; +} +export fn fn1886() void { + dest_end = 3; + _ = src_ptr94[3..dest_end :1]; +} +export fn fn1887() void { + dest_end = 1; + _ = src_ptr94[3..dest_end :1]; +} +comptime { + _ = src_ptr94[3..][0..2 :1]; +} +comptime { + _ = src_ptr94[3..][0..3 :1]; +} +comptime { + _ = src_ptr94[3..][0..1 :1]; +} +export fn fn1888() void { + dest_len = 3; + _ = src_ptr94[3..][0..dest_len :1]; +} +export fn fn1889() void { + dest_len = 1; + _ = src_ptr94[3..][0..dest_len :1]; +} +const src_mem59: [1]u8 = .{0}; +const src_ptr95: [:0]const u8 = src_mem59[0..0 :0]; +comptime { + _ = src_ptr95[0..2]; +} +comptime { + _ = src_ptr95[0..3]; +} +comptime { + _ = src_ptr95[0..][0..2]; +} +comptime { + _ = src_ptr95[0..][0..3]; +} +comptime { + _ = src_ptr95[1..]; +} +comptime { + _ = src_ptr95[1..2]; +} +comptime { + _ = src_ptr95[1..3]; +} +comptime { + _ = src_ptr95[1..][0..2]; +} +comptime { + _ = src_ptr95[1..][0..3]; +} +comptime { + _ = src_ptr95[1..][0..1]; +} +comptime { + _ = src_ptr95[3..]; +} +comptime { + _ = src_ptr95[3..2]; +} +comptime { + _ = src_ptr95[3..3]; +} +comptime { + _ = src_ptr95[3..1]; +} +export fn fn1890() void { + dest_end = 3; + _ = src_ptr95[3..dest_end]; +} +export fn fn1891() void { + dest_end = 1; + _ = src_ptr95[3..dest_end]; +} +comptime { + _ = src_ptr95[3..][0..2]; +} +comptime { + _ = src_ptr95[3..][0..3]; +} +comptime { + _ = src_ptr95[3..][0..1]; +} +export fn fn1892() void { + dest_len = 3; + _ = src_ptr95[3..][0..dest_len]; +} +export fn fn1893() void { + dest_len = 1; + _ = src_ptr95[3..][0..dest_len]; +} +comptime { + _ = src_ptr95[0.. :1]; +} +comptime { + _ = src_ptr95[0..2 :1]; +} +comptime { + _ = src_ptr95[0..3 :1]; +} +comptime { + _ = src_ptr95[0..1 :1]; +} +comptime { + _ = src_ptr95[0..][0..2 :1]; +} +comptime { + _ = src_ptr95[0..][0..3 :1]; +} +comptime { + _ = src_ptr95[0..][0..1 :1]; +} +comptime { + _ = src_ptr95[1.. :1]; +} +comptime { + _ = src_ptr95[1..2 :1]; +} +comptime { + _ = src_ptr95[1..3 :1]; +} +comptime { + _ = src_ptr95[1..1 :1]; +} +export fn fn1894() void { + dest_end = 3; + _ = src_ptr95[1..dest_end :1]; +} +export fn fn1895() void { + dest_end = 1; + _ = src_ptr95[1..dest_end :1]; +} +comptime { + _ = src_ptr95[1..][0..2 :1]; +} +comptime { + _ = src_ptr95[1..][0..3 :1]; +} +comptime { + _ = src_ptr95[1..][0..1 :1]; +} +export fn fn1896() void { + dest_len = 3; + _ = src_ptr95[1..][0..dest_len :1]; +} +export fn fn1897() void { + dest_len = 1; + _ = src_ptr95[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr95[3.. :1]; +} +comptime { + _ = src_ptr95[3..2 :1]; +} +comptime { + _ = src_ptr95[3..3 :1]; +} +comptime { + _ = src_ptr95[3..1 :1]; +} +export fn fn1898() void { + dest_end = 3; + _ = src_ptr95[3..dest_end :1]; +} +export fn fn1899() void { + dest_end = 1; + _ = src_ptr95[3..dest_end :1]; +} +comptime { + _ = src_ptr95[3..][0..2 :1]; +} +comptime { + _ = src_ptr95[3..][0..3 :1]; +} +comptime { + _ = src_ptr95[3..][0..1 :1]; +} +export fn fn1900() void { + dest_len = 3; + _ = src_ptr95[3..][0..dest_len :1]; +} +export fn fn1901() void { + dest_len = 1; + _ = src_ptr95[3..][0..dest_len :1]; +} +const src_mem60: [2]u8 = .{ 0, 0 }; +var src_ptr96: []const u8 = src_mem60[0..2]; +export fn fn1902() void { + _ = src_ptr96[3..2]; +} +export fn fn1903() void { + _ = src_ptr96[3..1]; +} +export fn fn1904() void { + _ = src_ptr96[0.. :1]; +} +export fn fn1905() void { + _ = src_ptr96[1.. :1]; +} +export fn fn1906() void { + _ = src_ptr96[3.. :1]; +} +export fn fn1907() void { + _ = src_ptr96[3..2 :1]; +} +export fn fn1908() void { + _ = src_ptr96[3..1 :1]; +} +const src_mem61: [2]u8 = .{ 0, 0 }; +var src_ptr97: [:0]const u8 = src_mem61[0..1 :0]; +export fn fn1909() void { + _ = src_ptr97[3..2]; +} +export fn fn1910() void { + _ = src_ptr97[3..1]; +} +export fn fn1911() void { + _ = src_ptr97[3..2 :1]; +} +export fn fn1912() void { + _ = src_ptr97[3..1 :1]; +} +const src_mem62: [3]u8 = .{ 0, 0, 0 }; +var src_ptr98: []const u8 = src_mem62[0..3]; +export fn fn1913() void { + _ = src_ptr98[3..2]; +} +export fn fn1914() void { + _ = src_ptr98[3..1]; +} +export fn fn1915() void { + _ = src_ptr98[0.. :1]; +} +export fn fn1916() void { + _ = src_ptr98[1.. :1]; +} +export fn fn1917() void { + _ = src_ptr98[3.. :1]; +} +export fn fn1918() void { + _ = src_ptr98[3..2 :1]; +} +export fn fn1919() void { + _ = src_ptr98[3..1 :1]; +} +const src_mem63: [3]u8 = .{ 0, 0, 0 }; +var src_ptr99: [:0]const u8 = src_mem63[0..2 :0]; +export fn fn1920() void { + _ = src_ptr99[3..2]; +} +export fn fn1921() void { + _ = src_ptr99[3..1]; +} +export fn fn1922() void { + _ = src_ptr99[3..2 :1]; +} +export fn fn1923() void { + _ = src_ptr99[3..1 :1]; +} +const src_mem64: [1]u8 = .{0}; +var src_ptr100: []const u8 = src_mem64[0..1]; +export fn fn1924() void { + _ = src_ptr100[3..2]; +} +export fn fn1925() void { + _ = src_ptr100[3..1]; +} +export fn fn1926() void { + _ = src_ptr100[0.. :1]; +} +export fn fn1927() void { + _ = src_ptr100[1.. :1]; +} +export fn fn1928() void { + _ = src_ptr100[3.. :1]; +} +export fn fn1929() void { + _ = src_ptr100[3..2 :1]; +} +export fn fn1930() void { + _ = src_ptr100[3..1 :1]; +} +const src_mem65: [1]u8 = .{0}; +var src_ptr101: [:0]const u8 = src_mem65[0..0 :0]; +export fn fn1931() void { + _ = src_ptr101[3..2]; +} +export fn fn1932() void { + _ = src_ptr101[3..1]; +} +export fn fn1933() void { + _ = src_ptr101[3..2 :1]; +} +export fn fn1934() void { + _ = src_ptr101[3..1 :1]; +} +const src_mem66: [2]u8 = .{ 0, 0 }; +const src_ptr102: [*]const u8 = @ptrCast(&src_mem66); +comptime { + _ = src_ptr102[0..3]; +} +comptime { + _ = src_ptr102[0..][0..3]; +} +comptime { + _ = src_ptr102[1..3]; +} +comptime { + _ = src_ptr102[1..][0..2]; +} +comptime { + _ = src_ptr102[1..][0..3]; +} +comptime { + _ = src_ptr102[3..]; +} +comptime { + _ = src_ptr102[3..2]; +} +comptime { + _ = src_ptr102[3..3]; +} +comptime { + _ = src_ptr102[3..1]; +} +export fn fn1935() void { + dest_end = 3; + _ = src_ptr102[3..dest_end]; +} +export fn fn1936() void { + dest_end = 1; + _ = src_ptr102[3..dest_end]; +} +comptime { + _ = src_ptr102[3..][0..2]; +} +comptime { + _ = src_ptr102[3..][0..3]; +} +comptime { + _ = src_ptr102[3..][0..1]; +} +export fn fn1937() void { + dest_len = 3; + _ = src_ptr102[3..][0..dest_len]; +} +export fn fn1938() void { + dest_len = 1; + _ = src_ptr102[3..][0..dest_len]; +} +comptime { + _ = src_ptr102[0..2 :1]; +} +comptime { + _ = src_ptr102[0..3 :1]; +} +comptime { + _ = src_ptr102[0..1 :1]; +} +comptime { + _ = src_ptr102[0..][0..2 :1]; +} +comptime { + _ = src_ptr102[0..][0..3 :1]; +} +comptime { + _ = src_ptr102[0..][0..1 :1]; +} +comptime { + _ = src_ptr102[1..2 :1]; +} +comptime { + _ = src_ptr102[1..3 :1]; +} +comptime { + _ = src_ptr102[1..1 :1]; +} +comptime { + _ = src_ptr102[1..][0..2 :1]; +} +comptime { + _ = src_ptr102[1..][0..3 :1]; +} +comptime { + _ = src_ptr102[1..][0..1 :1]; +} +comptime { + _ = src_ptr102[3.. :1]; +} +comptime { + _ = src_ptr102[3..2 :1]; +} +comptime { + _ = src_ptr102[3..3 :1]; +} +comptime { + _ = src_ptr102[3..1 :1]; +} +export fn fn1939() void { + dest_end = 3; + _ = src_ptr102[3..dest_end :1]; +} +export fn fn1940() void { + dest_end = 1; + _ = src_ptr102[3..dest_end :1]; +} +comptime { + _ = src_ptr102[3..][0..2 :1]; +} +comptime { + _ = src_ptr102[3..][0..3 :1]; +} +comptime { + _ = src_ptr102[3..][0..1 :1]; +} +export fn fn1941() void { + dest_len = 3; + _ = src_ptr102[3..][0..dest_len :1]; +} +export fn fn1942() void { + dest_len = 1; + _ = src_ptr102[3..][0..dest_len :1]; +} +const src_mem67: [2]u8 = .{ 0, 0 }; +const src_ptr103: [*:0]const u8 = @ptrCast(&src_mem67); +comptime { + _ = src_ptr103[0..3]; +} +comptime { + _ = src_ptr103[0..][0..3]; +} +comptime { + _ = src_ptr103[1..3]; +} +comptime { + _ = src_ptr103[1..][0..2]; +} +comptime { + _ = src_ptr103[1..][0..3]; +} +comptime { + _ = src_ptr103[3..]; +} +comptime { + _ = src_ptr103[3..2]; +} +comptime { + _ = src_ptr103[3..3]; +} +comptime { + _ = src_ptr103[3..1]; +} +export fn fn1943() void { + dest_end = 3; + _ = src_ptr103[3..dest_end]; +} +export fn fn1944() void { + dest_end = 1; + _ = src_ptr103[3..dest_end]; +} +comptime { + _ = src_ptr103[3..][0..2]; +} +comptime { + _ = src_ptr103[3..][0..3]; +} +comptime { + _ = src_ptr103[3..][0..1]; +} +export fn fn1945() void { + dest_len = 3; + _ = src_ptr103[3..][0..dest_len]; +} +export fn fn1946() void { + dest_len = 1; + _ = src_ptr103[3..][0..dest_len]; +} +comptime { + _ = src_ptr103[0..2 :1]; +} +comptime { + _ = src_ptr103[0..3 :1]; +} +comptime { + _ = src_ptr103[0..1 :1]; +} +comptime { + _ = src_ptr103[0..][0..2 :1]; +} +comptime { + _ = src_ptr103[0..][0..3 :1]; +} +comptime { + _ = src_ptr103[0..][0..1 :1]; +} +comptime { + _ = src_ptr103[1..2 :1]; +} +comptime { + _ = src_ptr103[1..3 :1]; +} +comptime { + _ = src_ptr103[1..1 :1]; +} +comptime { + _ = src_ptr103[1..][0..2 :1]; +} +comptime { + _ = src_ptr103[1..][0..3 :1]; +} +comptime { + _ = src_ptr103[1..][0..1 :1]; +} +comptime { + _ = src_ptr103[3.. :1]; +} +comptime { + _ = src_ptr103[3..2 :1]; +} +comptime { + _ = src_ptr103[3..3 :1]; +} +comptime { + _ = src_ptr103[3..1 :1]; +} +export fn fn1947() void { + dest_end = 3; + _ = src_ptr103[3..dest_end :1]; +} +export fn fn1948() void { + dest_end = 1; + _ = src_ptr103[3..dest_end :1]; +} +comptime { + _ = src_ptr103[3..][0..2 :1]; +} +comptime { + _ = src_ptr103[3..][0..3 :1]; +} +comptime { + _ = src_ptr103[3..][0..1 :1]; +} +export fn fn1949() void { + dest_len = 3; + _ = src_ptr103[3..][0..dest_len :1]; +} +export fn fn1950() void { + dest_len = 1; + _ = src_ptr103[3..][0..dest_len :1]; +} +const src_mem68: [3]u8 = .{ 0, 0, 0 }; +const src_ptr104: [*]const u8 = @ptrCast(&src_mem68); +comptime { + _ = src_ptr104[1..][0..3]; +} +comptime { + _ = src_ptr104[3..2]; +} +comptime { + _ = src_ptr104[3..1]; +} +comptime { + _ = src_ptr104[3..][0..2]; +} +comptime { + _ = src_ptr104[3..][0..3]; +} +comptime { + _ = src_ptr104[3..][0..1]; +} +comptime { + _ = src_ptr104[0..2 :1]; +} +comptime { + _ = src_ptr104[0..3 :1]; +} +comptime { + _ = src_ptr104[0..1 :1]; +} +comptime { + _ = src_ptr104[0..][0..2 :1]; +} +comptime { + _ = src_ptr104[0..][0..3 :1]; +} +comptime { + _ = src_ptr104[0..][0..1 :1]; +} +comptime { + _ = src_ptr104[1..2 :1]; +} +comptime { + _ = src_ptr104[1..3 :1]; +} +comptime { + _ = src_ptr104[1..1 :1]; +} +comptime { + _ = src_ptr104[1..][0..2 :1]; +} +comptime { + _ = src_ptr104[1..][0..3 :1]; +} +comptime { + _ = src_ptr104[1..][0..1 :1]; +} +comptime { + _ = src_ptr104[3.. :1]; +} +comptime { + _ = src_ptr104[3..2 :1]; +} +comptime { + _ = src_ptr104[3..3 :1]; +} +comptime { + _ = src_ptr104[3..1 :1]; +} +export fn fn1951() void { + dest_end = 3; + _ = src_ptr104[3..dest_end :1]; +} +export fn fn1952() void { + dest_end = 1; + _ = src_ptr104[3..dest_end :1]; +} +comptime { + _ = src_ptr104[3..][0..2 :1]; +} +comptime { + _ = src_ptr104[3..][0..3 :1]; +} +comptime { + _ = src_ptr104[3..][0..1 :1]; +} +export fn fn1953() void { + dest_len = 3; + _ = src_ptr104[3..][0..dest_len :1]; +} +export fn fn1954() void { + dest_len = 1; + _ = src_ptr104[3..][0..dest_len :1]; +} +const src_mem69: [3]u8 = .{ 0, 0, 0 }; +const src_ptr105: [*:0]const u8 = @ptrCast(&src_mem69); +comptime { + _ = src_ptr105[1..][0..3]; +} +comptime { + _ = src_ptr105[3..2]; +} +comptime { + _ = src_ptr105[3..1]; +} +comptime { + _ = src_ptr105[3..][0..2]; +} +comptime { + _ = src_ptr105[3..][0..3]; +} +comptime { + _ = src_ptr105[3..][0..1]; +} +comptime { + _ = src_ptr105[0..2 :1]; +} +comptime { + _ = src_ptr105[0..3 :1]; +} +comptime { + _ = src_ptr105[0..1 :1]; +} +comptime { + _ = src_ptr105[0..][0..2 :1]; +} +comptime { + _ = src_ptr105[0..][0..3 :1]; +} +comptime { + _ = src_ptr105[0..][0..1 :1]; +} +comptime { + _ = src_ptr105[1..2 :1]; +} +comptime { + _ = src_ptr105[1..3 :1]; +} +comptime { + _ = src_ptr105[1..1 :1]; +} +comptime { + _ = src_ptr105[1..][0..2 :1]; +} +comptime { + _ = src_ptr105[1..][0..3 :1]; +} +comptime { + _ = src_ptr105[1..][0..1 :1]; +} +comptime { + _ = src_ptr105[3.. :1]; +} +comptime { + _ = src_ptr105[3..2 :1]; +} +comptime { + _ = src_ptr105[3..3 :1]; +} +comptime { + _ = src_ptr105[3..1 :1]; +} +export fn fn1955() void { + dest_end = 3; + _ = src_ptr105[3..dest_end :1]; +} +export fn fn1956() void { + dest_end = 1; + _ = src_ptr105[3..dest_end :1]; +} +comptime { + _ = src_ptr105[3..][0..2 :1]; +} +comptime { + _ = src_ptr105[3..][0..3 :1]; +} +comptime { + _ = src_ptr105[3..][0..1 :1]; +} +export fn fn1957() void { + dest_len = 3; + _ = src_ptr105[3..][0..dest_len :1]; +} +export fn fn1958() void { + dest_len = 1; + _ = src_ptr105[3..][0..dest_len :1]; +} +const src_mem70: [1]u8 = .{0}; +const src_ptr106: [*]const u8 = @ptrCast(&src_mem70); +comptime { + _ = src_ptr106[0..2]; +} +comptime { + _ = src_ptr106[0..3]; +} +comptime { + _ = src_ptr106[0..][0..2]; +} +comptime { + _ = src_ptr106[0..][0..3]; +} +comptime { + _ = src_ptr106[1..2]; +} +comptime { + _ = src_ptr106[1..3]; +} +comptime { + _ = src_ptr106[1..][0..2]; +} +comptime { + _ = src_ptr106[1..][0..3]; +} +comptime { + _ = src_ptr106[1..][0..1]; +} +comptime { + _ = src_ptr106[3..]; +} +comptime { + _ = src_ptr106[3..2]; +} +comptime { + _ = src_ptr106[3..3]; +} +comptime { + _ = src_ptr106[3..1]; +} +export fn fn1959() void { + dest_end = 3; + _ = src_ptr106[3..dest_end]; +} +export fn fn1960() void { + dest_end = 1; + _ = src_ptr106[3..dest_end]; +} +comptime { + _ = src_ptr106[3..][0..2]; +} +comptime { + _ = src_ptr106[3..][0..3]; +} +comptime { + _ = src_ptr106[3..][0..1]; +} +export fn fn1961() void { + dest_len = 3; + _ = src_ptr106[3..][0..dest_len]; +} +export fn fn1962() void { + dest_len = 1; + _ = src_ptr106[3..][0..dest_len]; +} +comptime { + _ = src_ptr106[0..2 :1]; +} +comptime { + _ = src_ptr106[0..3 :1]; +} +comptime { + _ = src_ptr106[0..1 :1]; +} +comptime { + _ = src_ptr106[0..][0..2 :1]; +} +comptime { + _ = src_ptr106[0..][0..3 :1]; +} +comptime { + _ = src_ptr106[0..][0..1 :1]; +} +comptime { + _ = src_ptr106[1.. :1]; +} +comptime { + _ = src_ptr106[1..2 :1]; +} +comptime { + _ = src_ptr106[1..3 :1]; +} +comptime { + _ = src_ptr106[1..1 :1]; +} +export fn fn1963() void { + dest_end = 3; + _ = src_ptr106[1..dest_end :1]; +} +export fn fn1964() void { + dest_end = 1; + _ = src_ptr106[1..dest_end :1]; +} +comptime { + _ = src_ptr106[1..][0..2 :1]; +} +comptime { + _ = src_ptr106[1..][0..3 :1]; +} +comptime { + _ = src_ptr106[1..][0..1 :1]; +} +export fn fn1965() void { + dest_len = 3; + _ = src_ptr106[1..][0..dest_len :1]; +} +export fn fn1966() void { + dest_len = 1; + _ = src_ptr106[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr106[3.. :1]; +} +comptime { + _ = src_ptr106[3..2 :1]; +} +comptime { + _ = src_ptr106[3..3 :1]; +} +comptime { + _ = src_ptr106[3..1 :1]; +} +export fn fn1967() void { + dest_end = 3; + _ = src_ptr106[3..dest_end :1]; +} +export fn fn1968() void { + dest_end = 1; + _ = src_ptr106[3..dest_end :1]; +} +comptime { + _ = src_ptr106[3..][0..2 :1]; +} +comptime { + _ = src_ptr106[3..][0..3 :1]; +} +comptime { + _ = src_ptr106[3..][0..1 :1]; +} +export fn fn1969() void { + dest_len = 3; + _ = src_ptr106[3..][0..dest_len :1]; +} +export fn fn1970() void { + dest_len = 1; + _ = src_ptr106[3..][0..dest_len :1]; +} +const src_mem71: [1]u8 = .{0}; +const src_ptr107: [*:0]const u8 = @ptrCast(&src_mem71); +comptime { + _ = src_ptr107[0..2]; +} +comptime { + _ = src_ptr107[0..3]; +} +comptime { + _ = src_ptr107[0..][0..2]; +} +comptime { + _ = src_ptr107[0..][0..3]; +} +comptime { + _ = src_ptr107[1..2]; +} +comptime { + _ = src_ptr107[1..3]; +} +comptime { + _ = src_ptr107[1..][0..2]; +} +comptime { + _ = src_ptr107[1..][0..3]; +} +comptime { + _ = src_ptr107[1..][0..1]; +} +comptime { + _ = src_ptr107[3..]; +} +comptime { + _ = src_ptr107[3..2]; +} +comptime { + _ = src_ptr107[3..3]; +} +comptime { + _ = src_ptr107[3..1]; +} +export fn fn1971() void { + dest_end = 3; + _ = src_ptr107[3..dest_end]; +} +export fn fn1972() void { + dest_end = 1; + _ = src_ptr107[3..dest_end]; +} +comptime { + _ = src_ptr107[3..][0..2]; +} +comptime { + _ = src_ptr107[3..][0..3]; +} +comptime { + _ = src_ptr107[3..][0..1]; +} +export fn fn1973() void { + dest_len = 3; + _ = src_ptr107[3..][0..dest_len]; +} +export fn fn1974() void { + dest_len = 1; + _ = src_ptr107[3..][0..dest_len]; +} +comptime { + _ = src_ptr107[0..2 :1]; +} +comptime { + _ = src_ptr107[0..3 :1]; +} +comptime { + _ = src_ptr107[0..1 :1]; +} +comptime { + _ = src_ptr107[0..][0..2 :1]; +} +comptime { + _ = src_ptr107[0..][0..3 :1]; +} +comptime { + _ = src_ptr107[0..][0..1 :1]; +} +comptime { + _ = src_ptr107[1.. :1]; +} +comptime { + _ = src_ptr107[1..2 :1]; +} +comptime { + _ = src_ptr107[1..3 :1]; +} +comptime { + _ = src_ptr107[1..1 :1]; +} +export fn fn1975() void { + dest_end = 3; + _ = src_ptr107[1..dest_end :1]; +} +export fn fn1976() void { + dest_end = 1; + _ = src_ptr107[1..dest_end :1]; +} +comptime { + _ = src_ptr107[1..][0..2 :1]; +} +comptime { + _ = src_ptr107[1..][0..3 :1]; +} +comptime { + _ = src_ptr107[1..][0..1 :1]; +} +export fn fn1977() void { + dest_len = 3; + _ = src_ptr107[1..][0..dest_len :1]; +} +export fn fn1978() void { + dest_len = 1; + _ = src_ptr107[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr107[3.. :1]; +} +comptime { + _ = src_ptr107[3..2 :1]; +} +comptime { + _ = src_ptr107[3..3 :1]; +} +comptime { + _ = src_ptr107[3..1 :1]; +} +export fn fn1979() void { + dest_end = 3; + _ = src_ptr107[3..dest_end :1]; +} +export fn fn1980() void { + dest_end = 1; + _ = src_ptr107[3..dest_end :1]; +} +comptime { + _ = src_ptr107[3..][0..2 :1]; +} +comptime { + _ = src_ptr107[3..][0..3 :1]; +} +comptime { + _ = src_ptr107[3..][0..1 :1]; +} +export fn fn1981() void { + dest_len = 3; + _ = src_ptr107[3..][0..dest_len :1]; +} +export fn fn1982() void { + dest_len = 1; + _ = src_ptr107[3..][0..dest_len :1]; +} +const src_mem72: [2]u8 = .{ 0, 0 }; +var src_ptr108: [*]const u8 = @ptrCast(&src_mem72); +export fn fn1983() void { + _ = src_ptr108[3..2]; +} +export fn fn1984() void { + _ = src_ptr108[3..1]; +} +export fn fn1985() void { + _ = src_ptr108[3..2 :1]; +} +export fn fn1986() void { + _ = src_ptr108[3..1 :1]; +} +const src_mem73: [2]u8 = .{ 0, 0 }; +var src_ptr109: [*:0]const u8 = @ptrCast(&src_mem73); +export fn fn1987() void { + _ = src_ptr109[3..2]; +} +export fn fn1988() void { + _ = src_ptr109[3..1]; +} +export fn fn1989() void { + _ = src_ptr109[3..2 :1]; +} +export fn fn1990() void { + _ = src_ptr109[3..1 :1]; +} +const src_mem74: [3]u8 = .{ 0, 0, 0 }; +var src_ptr110: [*]const u8 = @ptrCast(&src_mem74); +export fn fn1991() void { + _ = src_ptr110[3..2]; +} +export fn fn1992() void { + _ = src_ptr110[3..1]; +} +export fn fn1993() void { + _ = src_ptr110[3..2 :1]; +} +export fn fn1994() void { + _ = src_ptr110[3..1 :1]; +} +const src_mem75: [3]u8 = .{ 0, 0, 0 }; +var src_ptr111: [*:0]const u8 = @ptrCast(&src_mem75); +export fn fn1995() void { + _ = src_ptr111[3..2]; +} +export fn fn1996() void { + _ = src_ptr111[3..1]; +} +export fn fn1997() void { + _ = src_ptr111[3..2 :1]; +} +export fn fn1998() void { + _ = src_ptr111[3..1 :1]; +} +const src_mem76: [1]u8 = .{0}; +var src_ptr112: [*]const u8 = @ptrCast(&src_mem76); +export fn fn1999() void { + _ = src_ptr112[3..2]; +} +export fn fn2000() void { + _ = src_ptr112[3..1]; +} +export fn fn2001() void { + _ = src_ptr112[3..2 :1]; +} +export fn fn2002() void { + _ = src_ptr112[3..1 :1]; +} +const src_mem77: [1]u8 = .{0}; +var src_ptr113: [*:0]const u8 = @ptrCast(&src_mem77); +export fn fn2003() void { + _ = src_ptr113[3..2]; +} +export fn fn2004() void { + _ = src_ptr113[3..1]; +} +export fn fn2005() void { + _ = src_ptr113[3..2 :1]; +} +export fn fn2006() void { + _ = src_ptr113[3..1 :1]; +} +const src_ptr114: [*c]const u8 = nullptr; +comptime { + _ = src_ptr114[0..]; +} +comptime { + _ = src_ptr114[0..2]; +} +comptime { + _ = src_ptr114[0..3]; +} +comptime { + _ = src_ptr114[0..1]; +} +export fn fn2007() void { + dest_end = 3; + _ = src_ptr114[0..dest_end]; +} +export fn fn2008() void { + dest_end = 1; + _ = src_ptr114[0..dest_end]; +} +comptime { + _ = src_ptr114[0..][0..2]; +} +comptime { + _ = src_ptr114[0..][0..3]; +} +comptime { + _ = src_ptr114[0..][0..1]; +} +export fn fn2009() void { + dest_len = 3; + _ = src_ptr114[0..][0..dest_len]; +} +export fn fn2010() void { + dest_len = 1; + _ = src_ptr114[0..][0..dest_len]; +} +comptime { + _ = src_ptr114[1..]; +} +comptime { + _ = src_ptr114[1..2]; +} +comptime { + _ = src_ptr114[1..3]; +} +comptime { + _ = src_ptr114[1..1]; +} +export fn fn2011() void { + dest_end = 3; + _ = src_ptr114[1..dest_end]; +} +export fn fn2012() void { + dest_end = 1; + _ = src_ptr114[1..dest_end]; +} +comptime { + _ = src_ptr114[1..][0..2]; +} +comptime { + _ = src_ptr114[1..][0..3]; +} +comptime { + _ = src_ptr114[1..][0..1]; +} +export fn fn2013() void { + dest_len = 3; + _ = src_ptr114[1..][0..dest_len]; +} +export fn fn2014() void { + dest_len = 1; + _ = src_ptr114[1..][0..dest_len]; +} +comptime { + _ = src_ptr114[3..]; +} +comptime { + _ = src_ptr114[3..2]; +} +comptime { + _ = src_ptr114[3..3]; +} +comptime { + _ = src_ptr114[3..1]; +} +export fn fn2015() void { + dest_end = 3; + _ = src_ptr114[3..dest_end]; +} +export fn fn2016() void { + dest_end = 1; + _ = src_ptr114[3..dest_end]; +} +comptime { + _ = src_ptr114[3..][0..2]; +} +comptime { + _ = src_ptr114[3..][0..3]; +} +comptime { + _ = src_ptr114[3..][0..1]; +} +export fn fn2017() void { + dest_len = 3; + _ = src_ptr114[3..][0..dest_len]; +} +export fn fn2018() void { + dest_len = 1; + _ = src_ptr114[3..][0..dest_len]; +} +comptime { + _ = src_ptr114[0.. :1]; +} +comptime { + _ = src_ptr114[0..2 :1]; +} +comptime { + _ = src_ptr114[0..3 :1]; +} +comptime { + _ = src_ptr114[0..1 :1]; +} +export fn fn2019() void { + dest_end = 3; + _ = src_ptr114[0..dest_end :1]; +} +export fn fn2020() void { + dest_end = 1; + _ = src_ptr114[0..dest_end :1]; +} +comptime { + _ = src_ptr114[0..][0..2 :1]; +} +comptime { + _ = src_ptr114[0..][0..3 :1]; +} +comptime { + _ = src_ptr114[0..][0..1 :1]; +} +export fn fn2021() void { + dest_len = 3; + _ = src_ptr114[0..][0..dest_len :1]; +} +export fn fn2022() void { + dest_len = 1; + _ = src_ptr114[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr114[1.. :1]; +} +comptime { + _ = src_ptr114[1..2 :1]; +} +comptime { + _ = src_ptr114[1..3 :1]; +} +comptime { + _ = src_ptr114[1..1 :1]; +} +export fn fn2023() void { + dest_end = 3; + _ = src_ptr114[1..dest_end :1]; +} +export fn fn2024() void { + dest_end = 1; + _ = src_ptr114[1..dest_end :1]; +} +comptime { + _ = src_ptr114[1..][0..2 :1]; +} +comptime { + _ = src_ptr114[1..][0..3 :1]; +} +comptime { + _ = src_ptr114[1..][0..1 :1]; +} +export fn fn2025() void { + dest_len = 3; + _ = src_ptr114[1..][0..dest_len :1]; +} +export fn fn2026() void { + dest_len = 1; + _ = src_ptr114[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr114[3.. :1]; +} +comptime { + _ = src_ptr114[3..2 :1]; +} +comptime { + _ = src_ptr114[3..3 :1]; +} +comptime { + _ = src_ptr114[3..1 :1]; +} +export fn fn2027() void { + dest_end = 3; + _ = src_ptr114[3..dest_end :1]; +} +export fn fn2028() void { + dest_end = 1; + _ = src_ptr114[3..dest_end :1]; +} +comptime { + _ = src_ptr114[3..][0..2 :1]; +} +comptime { + _ = src_ptr114[3..][0..3 :1]; +} +comptime { + _ = src_ptr114[3..][0..1 :1]; +} +export fn fn2029() void { + dest_len = 3; + _ = src_ptr114[3..][0..dest_len :1]; +} +export fn fn2030() void { + dest_len = 1; + _ = src_ptr114[3..][0..dest_len :1]; +} +const src_ptr115: [*c]const u8 = nullptr; +comptime { + _ = src_ptr115[0..]; +} +comptime { + _ = src_ptr115[0..2]; +} +comptime { + _ = src_ptr115[0..3]; +} +comptime { + _ = src_ptr115[0..1]; +} +export fn fn2031() void { + dest_end = 3; + _ = src_ptr115[0..dest_end]; +} +export fn fn2032() void { + dest_end = 1; + _ = src_ptr115[0..dest_end]; +} +comptime { + _ = src_ptr115[0..][0..2]; +} +comptime { + _ = src_ptr115[0..][0..3]; +} +comptime { + _ = src_ptr115[0..][0..1]; +} +export fn fn2033() void { + dest_len = 3; + _ = src_ptr115[0..][0..dest_len]; +} +export fn fn2034() void { + dest_len = 1; + _ = src_ptr115[0..][0..dest_len]; +} +comptime { + _ = src_ptr115[1..]; +} +comptime { + _ = src_ptr115[1..2]; +} +comptime { + _ = src_ptr115[1..3]; +} +comptime { + _ = src_ptr115[1..1]; +} +export fn fn2035() void { + dest_end = 3; + _ = src_ptr115[1..dest_end]; +} +export fn fn2036() void { + dest_end = 1; + _ = src_ptr115[1..dest_end]; +} +comptime { + _ = src_ptr115[1..][0..2]; +} +comptime { + _ = src_ptr115[1..][0..3]; +} +comptime { + _ = src_ptr115[1..][0..1]; +} +export fn fn2037() void { + dest_len = 3; + _ = src_ptr115[1..][0..dest_len]; +} +export fn fn2038() void { + dest_len = 1; + _ = src_ptr115[1..][0..dest_len]; +} +comptime { + _ = src_ptr115[3..]; +} +comptime { + _ = src_ptr115[3..2]; +} +comptime { + _ = src_ptr115[3..3]; +} +comptime { + _ = src_ptr115[3..1]; +} +export fn fn2039() void { + dest_end = 3; + _ = src_ptr115[3..dest_end]; +} +export fn fn2040() void { + dest_end = 1; + _ = src_ptr115[3..dest_end]; +} +comptime { + _ = src_ptr115[3..][0..2]; +} +comptime { + _ = src_ptr115[3..][0..3]; +} +comptime { + _ = src_ptr115[3..][0..1]; +} +export fn fn2041() void { + dest_len = 3; + _ = src_ptr115[3..][0..dest_len]; +} +export fn fn2042() void { + dest_len = 1; + _ = src_ptr115[3..][0..dest_len]; +} +comptime { + _ = src_ptr115[0.. :1]; +} +comptime { + _ = src_ptr115[0..2 :1]; +} +comptime { + _ = src_ptr115[0..3 :1]; +} +comptime { + _ = src_ptr115[0..1 :1]; +} +export fn fn2043() void { + dest_end = 3; + _ = src_ptr115[0..dest_end :1]; +} +export fn fn2044() void { + dest_end = 1; + _ = src_ptr115[0..dest_end :1]; +} +comptime { + _ = src_ptr115[0..][0..2 :1]; +} +comptime { + _ = src_ptr115[0..][0..3 :1]; +} +comptime { + _ = src_ptr115[0..][0..1 :1]; +} +export fn fn2045() void { + dest_len = 3; + _ = src_ptr115[0..][0..dest_len :1]; +} +export fn fn2046() void { + dest_len = 1; + _ = src_ptr115[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr115[1.. :1]; +} +comptime { + _ = src_ptr115[1..2 :1]; +} +comptime { + _ = src_ptr115[1..3 :1]; +} +comptime { + _ = src_ptr115[1..1 :1]; +} +export fn fn2047() void { + dest_end = 3; + _ = src_ptr115[1..dest_end :1]; +} +export fn fn2048() void { + dest_end = 1; + _ = src_ptr115[1..dest_end :1]; +} +comptime { + _ = src_ptr115[1..][0..2 :1]; +} +comptime { + _ = src_ptr115[1..][0..3 :1]; +} +comptime { + _ = src_ptr115[1..][0..1 :1]; +} +export fn fn2049() void { + dest_len = 3; + _ = src_ptr115[1..][0..dest_len :1]; +} +export fn fn2050() void { + dest_len = 1; + _ = src_ptr115[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr115[3.. :1]; +} +comptime { + _ = src_ptr115[3..2 :1]; +} +comptime { + _ = src_ptr115[3..3 :1]; +} +comptime { + _ = src_ptr115[3..1 :1]; +} +export fn fn2051() void { + dest_end = 3; + _ = src_ptr115[3..dest_end :1]; +} +export fn fn2052() void { + dest_end = 1; + _ = src_ptr115[3..dest_end :1]; +} +comptime { + _ = src_ptr115[3..][0..2 :1]; +} +comptime { + _ = src_ptr115[3..][0..3 :1]; +} +comptime { + _ = src_ptr115[3..][0..1 :1]; +} +export fn fn2053() void { + dest_len = 3; + _ = src_ptr115[3..][0..dest_len :1]; +} +export fn fn2054() void { + dest_len = 1; + _ = src_ptr115[3..][0..dest_len :1]; +} +const src_ptr116: [*c]const u8 = nullptr; +comptime { + _ = src_ptr116[0..]; +} +comptime { + _ = src_ptr116[0..2]; +} +comptime { + _ = src_ptr116[0..3]; +} +comptime { + _ = src_ptr116[0..1]; +} +export fn fn2055() void { + dest_end = 3; + _ = src_ptr116[0..dest_end]; +} +export fn fn2056() void { + dest_end = 1; + _ = src_ptr116[0..dest_end]; +} +comptime { + _ = src_ptr116[0..][0..2]; +} +comptime { + _ = src_ptr116[0..][0..3]; +} +comptime { + _ = src_ptr116[0..][0..1]; +} +export fn fn2057() void { + dest_len = 3; + _ = src_ptr116[0..][0..dest_len]; +} +export fn fn2058() void { + dest_len = 1; + _ = src_ptr116[0..][0..dest_len]; +} +comptime { + _ = src_ptr116[1..]; +} +comptime { + _ = src_ptr116[1..2]; +} +comptime { + _ = src_ptr116[1..3]; +} +comptime { + _ = src_ptr116[1..1]; +} +export fn fn2059() void { + dest_end = 3; + _ = src_ptr116[1..dest_end]; +} +export fn fn2060() void { + dest_end = 1; + _ = src_ptr116[1..dest_end]; +} +comptime { + _ = src_ptr116[1..][0..2]; +} +comptime { + _ = src_ptr116[1..][0..3]; +} +comptime { + _ = src_ptr116[1..][0..1]; +} +export fn fn2061() void { + dest_len = 3; + _ = src_ptr116[1..][0..dest_len]; +} +export fn fn2062() void { + dest_len = 1; + _ = src_ptr116[1..][0..dest_len]; +} +comptime { + _ = src_ptr116[3..]; +} +comptime { + _ = src_ptr116[3..2]; +} +comptime { + _ = src_ptr116[3..3]; +} +comptime { + _ = src_ptr116[3..1]; +} +export fn fn2063() void { + dest_end = 3; + _ = src_ptr116[3..dest_end]; +} +export fn fn2064() void { + dest_end = 1; + _ = src_ptr116[3..dest_end]; +} +comptime { + _ = src_ptr116[3..][0..2]; +} +comptime { + _ = src_ptr116[3..][0..3]; +} +comptime { + _ = src_ptr116[3..][0..1]; +} +export fn fn2065() void { + dest_len = 3; + _ = src_ptr116[3..][0..dest_len]; +} +export fn fn2066() void { + dest_len = 1; + _ = src_ptr116[3..][0..dest_len]; +} +comptime { + _ = src_ptr116[0.. :1]; +} +comptime { + _ = src_ptr116[0..2 :1]; +} +comptime { + _ = src_ptr116[0..3 :1]; +} +comptime { + _ = src_ptr116[0..1 :1]; +} +export fn fn2067() void { + dest_end = 3; + _ = src_ptr116[0..dest_end :1]; +} +export fn fn2068() void { + dest_end = 1; + _ = src_ptr116[0..dest_end :1]; +} +comptime { + _ = src_ptr116[0..][0..2 :1]; +} +comptime { + _ = src_ptr116[0..][0..3 :1]; +} +comptime { + _ = src_ptr116[0..][0..1 :1]; +} +export fn fn2069() void { + dest_len = 3; + _ = src_ptr116[0..][0..dest_len :1]; +} +export fn fn2070() void { + dest_len = 1; + _ = src_ptr116[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr116[1.. :1]; +} +comptime { + _ = src_ptr116[1..2 :1]; +} +comptime { + _ = src_ptr116[1..3 :1]; +} +comptime { + _ = src_ptr116[1..1 :1]; +} +export fn fn2071() void { + dest_end = 3; + _ = src_ptr116[1..dest_end :1]; +} +export fn fn2072() void { + dest_end = 1; + _ = src_ptr116[1..dest_end :1]; +} +comptime { + _ = src_ptr116[1..][0..2 :1]; +} +comptime { + _ = src_ptr116[1..][0..3 :1]; +} +comptime { + _ = src_ptr116[1..][0..1 :1]; +} +export fn fn2073() void { + dest_len = 3; + _ = src_ptr116[1..][0..dest_len :1]; +} +export fn fn2074() void { + dest_len = 1; + _ = src_ptr116[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr116[3.. :1]; +} +comptime { + _ = src_ptr116[3..2 :1]; +} +comptime { + _ = src_ptr116[3..3 :1]; +} +comptime { + _ = src_ptr116[3..1 :1]; +} +export fn fn2075() void { + dest_end = 3; + _ = src_ptr116[3..dest_end :1]; +} +export fn fn2076() void { + dest_end = 1; + _ = src_ptr116[3..dest_end :1]; +} +comptime { + _ = src_ptr116[3..][0..2 :1]; +} +comptime { + _ = src_ptr116[3..][0..3 :1]; +} +comptime { + _ = src_ptr116[3..][0..1 :1]; +} +export fn fn2077() void { + dest_len = 3; + _ = src_ptr116[3..][0..dest_len :1]; +} +export fn fn2078() void { + dest_len = 1; + _ = src_ptr116[3..][0..dest_len :1]; +} +var src_ptr117: [*c]const u8 = null; +export fn fn2079() void { + _ = src_ptr117[3..2]; +} +export fn fn2080() void { + _ = src_ptr117[3..1]; +} +export fn fn2081() void { + _ = src_ptr117[3..2 :1]; +} +export fn fn2082() void { + _ = src_ptr117[3..1 :1]; +} +var src_ptr118: [*c]const u8 = null; +export fn fn2083() void { + _ = src_ptr118[3..2]; +} +export fn fn2084() void { + _ = src_ptr118[3..1]; +} +export fn fn2085() void { + _ = src_ptr118[3..2 :1]; +} +export fn fn2086() void { + _ = src_ptr118[3..1 :1]; +} +var src_ptr119: [*c]const u8 = null; +export fn fn2087() void { + _ = src_ptr119[3..2]; +} +export fn fn2088() void { + _ = src_ptr119[3..1]; +} +export fn fn2089() void { + _ = src_ptr119[3..2 :1]; +} +export fn fn2090() void { + _ = src_ptr119[3..1 :1]; +} +const src_mem78: [2]u8 = .{ 0, 0 }; +const src_ptr120: [*c]const u8 = @ptrCast(&src_mem78); +comptime { + _ = src_ptr120[0..3]; +} +comptime { + _ = src_ptr120[0..][0..3]; +} +comptime { + _ = src_ptr120[1..3]; +} +comptime { + _ = src_ptr120[1..][0..2]; +} +comptime { + _ = src_ptr120[1..][0..3]; +} +comptime { + _ = src_ptr120[3..]; +} +comptime { + _ = src_ptr120[3..2]; +} +comptime { + _ = src_ptr120[3..3]; +} +comptime { + _ = src_ptr120[3..1]; +} +export fn fn2091() void { + dest_end = 3; + _ = src_ptr120[3..dest_end]; +} +export fn fn2092() void { + dest_end = 1; + _ = src_ptr120[3..dest_end]; +} +comptime { + _ = src_ptr120[3..][0..2]; +} +comptime { + _ = src_ptr120[3..][0..3]; +} +comptime { + _ = src_ptr120[3..][0..1]; +} +export fn fn2093() void { + dest_len = 3; + _ = src_ptr120[3..][0..dest_len]; +} +export fn fn2094() void { + dest_len = 1; + _ = src_ptr120[3..][0..dest_len]; +} +comptime { + _ = src_ptr120[0..2 :1]; +} +comptime { + _ = src_ptr120[0..3 :1]; +} +comptime { + _ = src_ptr120[0..1 :1]; +} +comptime { + _ = src_ptr120[0..][0..2 :1]; +} +comptime { + _ = src_ptr120[0..][0..3 :1]; +} +comptime { + _ = src_ptr120[0..][0..1 :1]; +} +comptime { + _ = src_ptr120[1..2 :1]; +} +comptime { + _ = src_ptr120[1..3 :1]; +} +comptime { + _ = src_ptr120[1..1 :1]; +} +comptime { + _ = src_ptr120[1..][0..2 :1]; +} +comptime { + _ = src_ptr120[1..][0..3 :1]; +} +comptime { + _ = src_ptr120[1..][0..1 :1]; +} +comptime { + _ = src_ptr120[3.. :1]; +} +comptime { + _ = src_ptr120[3..2 :1]; +} +comptime { + _ = src_ptr120[3..3 :1]; +} +comptime { + _ = src_ptr120[3..1 :1]; +} +export fn fn2095() void { + dest_end = 3; + _ = src_ptr120[3..dest_end :1]; +} +export fn fn2096() void { + dest_end = 1; + _ = src_ptr120[3..dest_end :1]; +} +comptime { + _ = src_ptr120[3..][0..2 :1]; +} +comptime { + _ = src_ptr120[3..][0..3 :1]; +} +comptime { + _ = src_ptr120[3..][0..1 :1]; +} +export fn fn2097() void { + dest_len = 3; + _ = src_ptr120[3..][0..dest_len :1]; +} +export fn fn2098() void { + dest_len = 1; + _ = src_ptr120[3..][0..dest_len :1]; +} +const src_mem79: [3]u8 = .{ 0, 0, 0 }; +const src_ptr121: [*c]const u8 = @ptrCast(&src_mem79); +comptime { + _ = src_ptr121[1..][0..3]; +} +comptime { + _ = src_ptr121[3..2]; +} +comptime { + _ = src_ptr121[3..1]; +} +comptime { + _ = src_ptr121[3..][0..2]; +} +comptime { + _ = src_ptr121[3..][0..3]; +} +comptime { + _ = src_ptr121[3..][0..1]; +} +comptime { + _ = src_ptr121[0..2 :1]; +} +comptime { + _ = src_ptr121[0..3 :1]; +} +comptime { + _ = src_ptr121[0..1 :1]; +} +comptime { + _ = src_ptr121[0..][0..2 :1]; +} +comptime { + _ = src_ptr121[0..][0..3 :1]; +} +comptime { + _ = src_ptr121[0..][0..1 :1]; +} +comptime { + _ = src_ptr121[1..2 :1]; +} +comptime { + _ = src_ptr121[1..3 :1]; +} +comptime { + _ = src_ptr121[1..1 :1]; +} +comptime { + _ = src_ptr121[1..][0..2 :1]; +} +comptime { + _ = src_ptr121[1..][0..3 :1]; +} +comptime { + _ = src_ptr121[1..][0..1 :1]; +} +comptime { + _ = src_ptr121[3.. :1]; +} +comptime { + _ = src_ptr121[3..2 :1]; +} +comptime { + _ = src_ptr121[3..3 :1]; +} +comptime { + _ = src_ptr121[3..1 :1]; +} +export fn fn2099() void { + dest_end = 3; + _ = src_ptr121[3..dest_end :1]; +} +export fn fn2100() void { + dest_end = 1; + _ = src_ptr121[3..dest_end :1]; +} +comptime { + _ = src_ptr121[3..][0..2 :1]; +} +comptime { + _ = src_ptr121[3..][0..3 :1]; +} +comptime { + _ = src_ptr121[3..][0..1 :1]; +} +export fn fn2101() void { + dest_len = 3; + _ = src_ptr121[3..][0..dest_len :1]; +} +export fn fn2102() void { + dest_len = 1; + _ = src_ptr121[3..][0..dest_len :1]; +} +const src_mem80: [1]u8 = .{0}; +const src_ptr122: [*c]const u8 = @ptrCast(&src_mem80); +comptime { + _ = src_ptr122[0..2]; +} +comptime { + _ = src_ptr122[0..3]; +} +comptime { + _ = src_ptr122[0..][0..2]; +} +comptime { + _ = src_ptr122[0..][0..3]; +} +comptime { + _ = src_ptr122[1..2]; +} +comptime { + _ = src_ptr122[1..3]; +} +comptime { + _ = src_ptr122[1..][0..2]; +} +comptime { + _ = src_ptr122[1..][0..3]; +} +comptime { + _ = src_ptr122[1..][0..1]; +} +comptime { + _ = src_ptr122[3..]; +} +comptime { + _ = src_ptr122[3..2]; +} +comptime { + _ = src_ptr122[3..3]; +} +comptime { + _ = src_ptr122[3..1]; +} +export fn fn2103() void { + dest_end = 3; + _ = src_ptr122[3..dest_end]; +} +export fn fn2104() void { + dest_end = 1; + _ = src_ptr122[3..dest_end]; +} +comptime { + _ = src_ptr122[3..][0..2]; +} +comptime { + _ = src_ptr122[3..][0..3]; +} +comptime { + _ = src_ptr122[3..][0..1]; +} +export fn fn2105() void { + dest_len = 3; + _ = src_ptr122[3..][0..dest_len]; +} +export fn fn2106() void { + dest_len = 1; + _ = src_ptr122[3..][0..dest_len]; +} +comptime { + _ = src_ptr122[0..2 :1]; +} +comptime { + _ = src_ptr122[0..3 :1]; +} +comptime { + _ = src_ptr122[0..1 :1]; +} +comptime { + _ = src_ptr122[0..][0..2 :1]; +} +comptime { + _ = src_ptr122[0..][0..3 :1]; +} +comptime { + _ = src_ptr122[0..][0..1 :1]; +} +comptime { + _ = src_ptr122[1.. :1]; +} +comptime { + _ = src_ptr122[1..2 :1]; +} +comptime { + _ = src_ptr122[1..3 :1]; +} +comptime { + _ = src_ptr122[1..1 :1]; +} +export fn fn2107() void { + dest_end = 3; + _ = src_ptr122[1..dest_end :1]; +} +export fn fn2108() void { + dest_end = 1; + _ = src_ptr122[1..dest_end :1]; +} +comptime { + _ = src_ptr122[1..][0..2 :1]; +} +comptime { + _ = src_ptr122[1..][0..3 :1]; +} +comptime { + _ = src_ptr122[1..][0..1 :1]; +} +export fn fn2109() void { + dest_len = 3; + _ = src_ptr122[1..][0..dest_len :1]; +} +export fn fn2110() void { + dest_len = 1; + _ = src_ptr122[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr122[3.. :1]; +} +comptime { + _ = src_ptr122[3..2 :1]; +} +comptime { + _ = src_ptr122[3..3 :1]; +} +comptime { + _ = src_ptr122[3..1 :1]; +} +export fn fn2111() void { + dest_end = 3; + _ = src_ptr122[3..dest_end :1]; +} +export fn fn2112() void { + dest_end = 1; + _ = src_ptr122[3..dest_end :1]; +} +comptime { + _ = src_ptr122[3..][0..2 :1]; +} +comptime { + _ = src_ptr122[3..][0..3 :1]; +} +comptime { + _ = src_ptr122[3..][0..1 :1]; +} +export fn fn2113() void { + dest_len = 3; + _ = src_ptr122[3..][0..dest_len :1]; +} +export fn fn2114() void { + dest_len = 1; + _ = src_ptr122[3..][0..dest_len :1]; +} +const src_mem81: [2]u8 = .{ 0, 0 }; +var src_ptr123: [*c]const u8 = @ptrCast(&src_mem81); +export fn fn2115() void { + _ = src_ptr123[3..2]; +} +export fn fn2116() void { + _ = src_ptr123[3..1]; +} +export fn fn2117() void { + _ = src_ptr123[3..2 :1]; +} +export fn fn2118() void { + _ = src_ptr123[3..1 :1]; +} +const src_mem82: [3]u8 = .{ 0, 0, 0 }; +var src_ptr124: [*c]const u8 = @ptrCast(&src_mem82); +export fn fn2119() void { + _ = src_ptr124[3..2]; +} +export fn fn2120() void { + _ = src_ptr124[3..1]; +} +export fn fn2121() void { + _ = src_ptr124[3..2 :1]; +} +export fn fn2122() void { + _ = src_ptr124[3..1 :1]; +} +const src_mem83: [1]u8 = .{0}; +var src_ptr125: [*c]const u8 = @ptrCast(&src_mem83); +export fn fn2123() void { + _ = src_ptr125[3..2]; +} +export fn fn2124() void { + _ = src_ptr125[3..1]; +} +export fn fn2125() void { + _ = src_ptr125[3..2 :1]; +} +export fn fn2126() void { + _ = src_ptr125[3..1 :1]; +} +const src_mem84: [2]u8 = .{ 1, 1 }; +const src_ptr126: *const [2]u8 = src_mem84[0..2]; +comptime { + _ = src_ptr126[0..3]; +} +comptime { + _ = src_ptr126[0..][0..3]; +} +comptime { + _ = src_ptr126[1..3]; +} +comptime { + _ = src_ptr126[1..][0..2]; +} +comptime { + _ = src_ptr126[1..][0..3]; +} +comptime { + _ = src_ptr126[3..]; +} +comptime { + _ = src_ptr126[3..2]; +} +comptime { + _ = src_ptr126[3..3]; +} +comptime { + _ = src_ptr126[3..1]; +} +export fn fn2127() void { + dest_end = 3; + _ = src_ptr126[3..dest_end]; +} +export fn fn2128() void { + dest_end = 1; + _ = src_ptr126[3..dest_end]; +} +comptime { + _ = src_ptr126[3..][0..2]; +} +comptime { + _ = src_ptr126[3..][0..3]; +} +comptime { + _ = src_ptr126[3..][0..1]; +} +export fn fn2129() void { + dest_len = 3; + _ = src_ptr126[3..][0..dest_len]; +} +export fn fn2130() void { + dest_len = 1; + _ = src_ptr126[3..][0..dest_len]; +} +comptime { + _ = src_ptr126[0.. :1]; +} +comptime { + _ = src_ptr126[0..2 :1]; +} +comptime { + _ = src_ptr126[0..3 :1]; +} +comptime { + _ = src_ptr126[0..][0..2 :1]; +} +comptime { + _ = src_ptr126[0..][0..3 :1]; +} +comptime { + _ = src_ptr126[1.. :1]; +} +comptime { + _ = src_ptr126[1..2 :1]; +} +comptime { + _ = src_ptr126[1..3 :1]; +} +comptime { + _ = src_ptr126[1..][0..2 :1]; +} +comptime { + _ = src_ptr126[1..][0..3 :1]; +} +comptime { + _ = src_ptr126[1..][0..1 :1]; +} +comptime { + _ = src_ptr126[3.. :1]; +} +comptime { + _ = src_ptr126[3..2 :1]; +} +comptime { + _ = src_ptr126[3..3 :1]; +} +comptime { + _ = src_ptr126[3..1 :1]; +} +export fn fn2131() void { + dest_end = 3; + _ = src_ptr126[3..dest_end :1]; +} +export fn fn2132() void { + dest_end = 1; + _ = src_ptr126[3..dest_end :1]; +} +comptime { + _ = src_ptr126[3..][0..2 :1]; +} +comptime { + _ = src_ptr126[3..][0..3 :1]; +} +comptime { + _ = src_ptr126[3..][0..1 :1]; +} +export fn fn2133() void { + dest_len = 3; + _ = src_ptr126[3..][0..dest_len :1]; +} +export fn fn2134() void { + dest_len = 1; + _ = src_ptr126[3..][0..dest_len :1]; +} +const src_mem85: [2]u8 = .{ 1, 0 }; +const src_ptr127: *const [1:0]u8 = src_mem85[0..1 :0]; +comptime { + _ = src_ptr127[0..3]; +} +comptime { + _ = src_ptr127[0..][0..3]; +} +comptime { + _ = src_ptr127[1..3]; +} +comptime { + _ = src_ptr127[1..][0..2]; +} +comptime { + _ = src_ptr127[1..][0..3]; +} +comptime { + _ = src_ptr127[3..]; +} +comptime { + _ = src_ptr127[3..2]; +} +comptime { + _ = src_ptr127[3..3]; +} +comptime { + _ = src_ptr127[3..1]; +} +export fn fn2135() void { + dest_end = 3; + _ = src_ptr127[3..dest_end]; +} +export fn fn2136() void { + dest_end = 1; + _ = src_ptr127[3..dest_end]; +} +comptime { + _ = src_ptr127[3..][0..2]; +} +comptime { + _ = src_ptr127[3..][0..3]; +} +comptime { + _ = src_ptr127[3..][0..1]; +} +export fn fn2137() void { + dest_len = 3; + _ = src_ptr127[3..][0..dest_len]; +} +export fn fn2138() void { + dest_len = 1; + _ = src_ptr127[3..][0..dest_len]; +} +comptime { + _ = src_ptr127[0.. :1]; +} +comptime { + _ = src_ptr127[0..2 :1]; +} +comptime { + _ = src_ptr127[0..3 :1]; +} +comptime { + _ = src_ptr127[0..1 :1]; +} +comptime { + _ = src_ptr127[0..][0..2 :1]; +} +comptime { + _ = src_ptr127[0..][0..3 :1]; +} +comptime { + _ = src_ptr127[0..][0..1 :1]; +} +comptime { + _ = src_ptr127[1.. :1]; +} +comptime { + _ = src_ptr127[1..2 :1]; +} +comptime { + _ = src_ptr127[1..3 :1]; +} +comptime { + _ = src_ptr127[1..1 :1]; +} +comptime { + _ = src_ptr127[1..][0..2 :1]; +} +comptime { + _ = src_ptr127[1..][0..3 :1]; +} +comptime { + _ = src_ptr127[1..][0..1 :1]; +} +comptime { + _ = src_ptr127[3.. :1]; +} +comptime { + _ = src_ptr127[3..2 :1]; +} +comptime { + _ = src_ptr127[3..3 :1]; +} +comptime { + _ = src_ptr127[3..1 :1]; +} +export fn fn2139() void { + dest_end = 3; + _ = src_ptr127[3..dest_end :1]; +} +export fn fn2140() void { + dest_end = 1; + _ = src_ptr127[3..dest_end :1]; +} +comptime { + _ = src_ptr127[3..][0..2 :1]; +} +comptime { + _ = src_ptr127[3..][0..3 :1]; +} +comptime { + _ = src_ptr127[3..][0..1 :1]; +} +export fn fn2141() void { + dest_len = 3; + _ = src_ptr127[3..][0..dest_len :1]; +} +export fn fn2142() void { + dest_len = 1; + _ = src_ptr127[3..][0..dest_len :1]; +} +const src_mem86: [3]u8 = .{ 1, 1, 1 }; +const src_ptr128: *const [3]u8 = src_mem86[0..3]; +comptime { + _ = src_ptr128[1..][0..3]; +} +comptime { + _ = src_ptr128[3..2]; +} +comptime { + _ = src_ptr128[3..1]; +} +comptime { + _ = src_ptr128[3..][0..2]; +} +comptime { + _ = src_ptr128[3..][0..3]; +} +comptime { + _ = src_ptr128[3..][0..1]; +} +comptime { + _ = src_ptr128[0.. :1]; +} +comptime { + _ = src_ptr128[0..3 :1]; +} +comptime { + _ = src_ptr128[0..][0..3 :1]; +} +comptime { + _ = src_ptr128[1.. :1]; +} +comptime { + _ = src_ptr128[1..3 :1]; +} +comptime { + _ = src_ptr128[1..][0..2 :1]; +} +comptime { + _ = src_ptr128[1..][0..3 :1]; +} +comptime { + _ = src_ptr128[3.. :1]; +} +comptime { + _ = src_ptr128[3..2 :1]; +} +comptime { + _ = src_ptr128[3..3 :1]; +} +comptime { + _ = src_ptr128[3..1 :1]; +} +export fn fn2143() void { + dest_end = 3; + _ = src_ptr128[3..dest_end :1]; +} +export fn fn2144() void { + dest_end = 1; + _ = src_ptr128[3..dest_end :1]; +} +comptime { + _ = src_ptr128[3..][0..2 :1]; +} +comptime { + _ = src_ptr128[3..][0..3 :1]; +} +comptime { + _ = src_ptr128[3..][0..1 :1]; +} +export fn fn2145() void { + dest_len = 3; + _ = src_ptr128[3..][0..dest_len :1]; +} +export fn fn2146() void { + dest_len = 1; + _ = src_ptr128[3..][0..dest_len :1]; +} +const src_mem87: [3]u8 = .{ 1, 1, 0 }; +const src_ptr129: *const [2:0]u8 = src_mem87[0..2 :0]; +comptime { + _ = src_ptr129[1..][0..3]; +} +comptime { + _ = src_ptr129[3..]; +} +comptime { + _ = src_ptr129[3..2]; +} +comptime { + _ = src_ptr129[3..1]; +} +comptime { + _ = src_ptr129[3..][0..2]; +} +comptime { + _ = src_ptr129[3..][0..3]; +} +comptime { + _ = src_ptr129[3..][0..1]; +} +comptime { + _ = src_ptr129[0.. :1]; +} +comptime { + _ = src_ptr129[0..2 :1]; +} +comptime { + _ = src_ptr129[0..3 :1]; +} +comptime { + _ = src_ptr129[0..][0..2 :1]; +} +comptime { + _ = src_ptr129[0..][0..3 :1]; +} +comptime { + _ = src_ptr129[1.. :1]; +} +comptime { + _ = src_ptr129[1..2 :1]; +} +comptime { + _ = src_ptr129[1..3 :1]; +} +comptime { + _ = src_ptr129[1..][0..2 :1]; +} +comptime { + _ = src_ptr129[1..][0..3 :1]; +} +comptime { + _ = src_ptr129[1..][0..1 :1]; +} +comptime { + _ = src_ptr129[3.. :1]; +} +comptime { + _ = src_ptr129[3..2 :1]; +} +comptime { + _ = src_ptr129[3..3 :1]; +} +comptime { + _ = src_ptr129[3..1 :1]; +} +export fn fn2147() void { + dest_end = 3; + _ = src_ptr129[3..dest_end :1]; +} +export fn fn2148() void { + dest_end = 1; + _ = src_ptr129[3..dest_end :1]; +} +comptime { + _ = src_ptr129[3..][0..2 :1]; +} +comptime { + _ = src_ptr129[3..][0..3 :1]; +} +comptime { + _ = src_ptr129[3..][0..1 :1]; +} +export fn fn2149() void { + dest_len = 3; + _ = src_ptr129[3..][0..dest_len :1]; +} +export fn fn2150() void { + dest_len = 1; + _ = src_ptr129[3..][0..dest_len :1]; +} +const src_mem88: [1]u8 = .{1}; +const src_ptr130: *const [1]u8 = src_mem88[0..1]; +comptime { + _ = src_ptr130[0..2]; +} +comptime { + _ = src_ptr130[0..3]; +} +comptime { + _ = src_ptr130[0..][0..2]; +} +comptime { + _ = src_ptr130[0..][0..3]; +} +comptime { + _ = src_ptr130[1..2]; +} +comptime { + _ = src_ptr130[1..3]; +} +comptime { + _ = src_ptr130[1..][0..2]; +} +comptime { + _ = src_ptr130[1..][0..3]; +} +comptime { + _ = src_ptr130[1..][0..1]; +} +comptime { + _ = src_ptr130[3..]; +} +comptime { + _ = src_ptr130[3..2]; +} +comptime { + _ = src_ptr130[3..3]; +} +comptime { + _ = src_ptr130[3..1]; +} +export fn fn2151() void { + dest_end = 3; + _ = src_ptr130[3..dest_end]; +} +export fn fn2152() void { + dest_end = 1; + _ = src_ptr130[3..dest_end]; +} +comptime { + _ = src_ptr130[3..][0..2]; +} +comptime { + _ = src_ptr130[3..][0..3]; +} +comptime { + _ = src_ptr130[3..][0..1]; +} +export fn fn2153() void { + dest_len = 3; + _ = src_ptr130[3..][0..dest_len]; +} +export fn fn2154() void { + dest_len = 1; + _ = src_ptr130[3..][0..dest_len]; +} +comptime { + _ = src_ptr130[0.. :1]; +} +comptime { + _ = src_ptr130[0..2 :1]; +} +comptime { + _ = src_ptr130[0..3 :1]; +} +comptime { + _ = src_ptr130[0..1 :1]; +} +comptime { + _ = src_ptr130[0..][0..2 :1]; +} +comptime { + _ = src_ptr130[0..][0..3 :1]; +} +comptime { + _ = src_ptr130[0..][0..1 :1]; +} +comptime { + _ = src_ptr130[1.. :1]; +} +comptime { + _ = src_ptr130[1..2 :1]; +} +comptime { + _ = src_ptr130[1..3 :1]; +} +comptime { + _ = src_ptr130[1..1 :1]; +} +export fn fn2155() void { + dest_end = 3; + _ = src_ptr130[1..dest_end :1]; +} +export fn fn2156() void { + dest_end = 1; + _ = src_ptr130[1..dest_end :1]; +} +comptime { + _ = src_ptr130[1..][0..2 :1]; +} +comptime { + _ = src_ptr130[1..][0..3 :1]; +} +comptime { + _ = src_ptr130[1..][0..1 :1]; +} +export fn fn2157() void { + dest_len = 3; + _ = src_ptr130[1..][0..dest_len :1]; +} +export fn fn2158() void { + dest_len = 1; + _ = src_ptr130[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr130[3.. :1]; +} +comptime { + _ = src_ptr130[3..2 :1]; +} +comptime { + _ = src_ptr130[3..3 :1]; +} +comptime { + _ = src_ptr130[3..1 :1]; +} +export fn fn2159() void { + dest_end = 3; + _ = src_ptr130[3..dest_end :1]; +} +export fn fn2160() void { + dest_end = 1; + _ = src_ptr130[3..dest_end :1]; +} +comptime { + _ = src_ptr130[3..][0..2 :1]; +} +comptime { + _ = src_ptr130[3..][0..3 :1]; +} +comptime { + _ = src_ptr130[3..][0..1 :1]; +} +export fn fn2161() void { + dest_len = 3; + _ = src_ptr130[3..][0..dest_len :1]; +} +export fn fn2162() void { + dest_len = 1; + _ = src_ptr130[3..][0..dest_len :1]; +} +const src_mem89: [1]u8 = .{0}; +const src_ptr131: *const [0:0]u8 = src_mem89[0..0 :0]; +comptime { + _ = src_ptr131[0..2]; +} +comptime { + _ = src_ptr131[0..3]; +} +comptime { + _ = src_ptr131[0..][0..2]; +} +comptime { + _ = src_ptr131[0..][0..3]; +} +comptime { + _ = src_ptr131[1..]; +} +comptime { + _ = src_ptr131[1..2]; +} +comptime { + _ = src_ptr131[1..3]; +} +comptime { + _ = src_ptr131[1..][0..2]; +} +comptime { + _ = src_ptr131[1..][0..3]; +} +comptime { + _ = src_ptr131[1..][0..1]; +} +comptime { + _ = src_ptr131[3..]; +} +comptime { + _ = src_ptr131[3..2]; +} +comptime { + _ = src_ptr131[3..3]; +} +comptime { + _ = src_ptr131[3..1]; +} +export fn fn2163() void { + dest_end = 3; + _ = src_ptr131[3..dest_end]; +} +export fn fn2164() void { + dest_end = 1; + _ = src_ptr131[3..dest_end]; +} +comptime { + _ = src_ptr131[3..][0..2]; +} +comptime { + _ = src_ptr131[3..][0..3]; +} +comptime { + _ = src_ptr131[3..][0..1]; +} +export fn fn2165() void { + dest_len = 3; + _ = src_ptr131[3..][0..dest_len]; +} +export fn fn2166() void { + dest_len = 1; + _ = src_ptr131[3..][0..dest_len]; +} +comptime { + _ = src_ptr131[0.. :1]; +} +comptime { + _ = src_ptr131[0..2 :1]; +} +comptime { + _ = src_ptr131[0..3 :1]; +} +comptime { + _ = src_ptr131[0..1 :1]; +} +comptime { + _ = src_ptr131[0..][0..2 :1]; +} +comptime { + _ = src_ptr131[0..][0..3 :1]; +} +comptime { + _ = src_ptr131[0..][0..1 :1]; +} +comptime { + _ = src_ptr131[1.. :1]; +} +comptime { + _ = src_ptr131[1..2 :1]; +} +comptime { + _ = src_ptr131[1..3 :1]; +} +comptime { + _ = src_ptr131[1..1 :1]; +} +export fn fn2167() void { + dest_end = 3; + _ = src_ptr131[1..dest_end :1]; +} +export fn fn2168() void { + dest_end = 1; + _ = src_ptr131[1..dest_end :1]; +} +comptime { + _ = src_ptr131[1..][0..2 :1]; +} +comptime { + _ = src_ptr131[1..][0..3 :1]; +} +comptime { + _ = src_ptr131[1..][0..1 :1]; +} +export fn fn2169() void { + dest_len = 3; + _ = src_ptr131[1..][0..dest_len :1]; +} +export fn fn2170() void { + dest_len = 1; + _ = src_ptr131[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr131[3.. :1]; +} +comptime { + _ = src_ptr131[3..2 :1]; +} +comptime { + _ = src_ptr131[3..3 :1]; +} +comptime { + _ = src_ptr131[3..1 :1]; +} +export fn fn2171() void { + dest_end = 3; + _ = src_ptr131[3..dest_end :1]; +} +export fn fn2172() void { + dest_end = 1; + _ = src_ptr131[3..dest_end :1]; +} +comptime { + _ = src_ptr131[3..][0..2 :1]; +} +comptime { + _ = src_ptr131[3..][0..3 :1]; +} +comptime { + _ = src_ptr131[3..][0..1 :1]; +} +export fn fn2173() void { + dest_len = 3; + _ = src_ptr131[3..][0..dest_len :1]; +} +export fn fn2174() void { + dest_len = 1; + _ = src_ptr131[3..][0..dest_len :1]; +} +const src_mem90: [2]u8 = .{ 1, 1 }; +var src_ptr132: *const [2]u8 = src_mem90[0..2]; +export fn fn2175() void { + _ = src_ptr132[0..3]; +} +export fn fn2176() void { + _ = src_ptr132[0..][0..3]; +} +export fn fn2177() void { + _ = src_ptr132[1..3]; +} +export fn fn2178() void { + _ = src_ptr132[1..][0..2]; +} +export fn fn2179() void { + _ = src_ptr132[1..][0..3]; +} +export fn fn2180() void { + _ = src_ptr132[3..]; +} +export fn fn2181() void { + _ = src_ptr132[3..2]; +} +export fn fn2182() void { + _ = src_ptr132[3..3]; +} +export fn fn2183() void { + _ = src_ptr132[3..1]; +} +export fn fn2184() void { + dest_end = 3; + _ = src_ptr132[3..dest_end]; +} +export fn fn2185() void { + dest_end = 1; + _ = src_ptr132[3..dest_end]; +} +export fn fn2186() void { + _ = src_ptr132[3..][0..2]; +} +export fn fn2187() void { + _ = src_ptr132[3..][0..3]; +} +export fn fn2188() void { + _ = src_ptr132[3..][0..1]; +} +export fn fn2189() void { + dest_len = 3; + _ = src_ptr132[3..][0..dest_len]; +} +export fn fn2190() void { + dest_len = 1; + _ = src_ptr132[3..][0..dest_len]; +} +export fn fn2191() void { + _ = src_ptr132[0.. :1]; +} +export fn fn2192() void { + _ = src_ptr132[0..2 :1]; +} +export fn fn2193() void { + _ = src_ptr132[0..3 :1]; +} +export fn fn2194() void { + _ = src_ptr132[0..][0..2 :1]; +} +export fn fn2195() void { + _ = src_ptr132[0..][0..3 :1]; +} +export fn fn2196() void { + _ = src_ptr132[1.. :1]; +} +export fn fn2197() void { + _ = src_ptr132[1..2 :1]; +} +export fn fn2198() void { + _ = src_ptr132[1..3 :1]; +} +export fn fn2199() void { + _ = src_ptr132[1..][0..2 :1]; +} +export fn fn2200() void { + _ = src_ptr132[1..][0..3 :1]; +} +export fn fn2201() void { + _ = src_ptr132[1..][0..1 :1]; +} +export fn fn2202() void { + _ = src_ptr132[3.. :1]; +} +export fn fn2203() void { + _ = src_ptr132[3..2 :1]; +} +export fn fn2204() void { + _ = src_ptr132[3..3 :1]; +} +export fn fn2205() void { + _ = src_ptr132[3..1 :1]; +} +export fn fn2206() void { + dest_end = 3; + _ = src_ptr132[3..dest_end :1]; +} +export fn fn2207() void { + dest_end = 1; + _ = src_ptr132[3..dest_end :1]; +} +export fn fn2208() void { + _ = src_ptr132[3..][0..2 :1]; +} +export fn fn2209() void { + _ = src_ptr132[3..][0..3 :1]; +} +export fn fn2210() void { + _ = src_ptr132[3..][0..1 :1]; +} +export fn fn2211() void { + dest_len = 3; + _ = src_ptr132[3..][0..dest_len :1]; +} +export fn fn2212() void { + dest_len = 1; + _ = src_ptr132[3..][0..dest_len :1]; +} +const src_mem91: [2]u8 = .{ 1, 0 }; +var src_ptr133: *const [1:0]u8 = src_mem91[0..1 :0]; +export fn fn2213() void { + _ = src_ptr133[0..3]; +} +export fn fn2214() void { + _ = src_ptr133[0..][0..3]; +} +export fn fn2215() void { + _ = src_ptr133[1..3]; +} +export fn fn2216() void { + _ = src_ptr133[1..][0..2]; +} +export fn fn2217() void { + _ = src_ptr133[1..][0..3]; +} +export fn fn2218() void { + _ = src_ptr133[3..]; +} +export fn fn2219() void { + _ = src_ptr133[3..2]; +} +export fn fn2220() void { + _ = src_ptr133[3..3]; +} +export fn fn2221() void { + _ = src_ptr133[3..1]; +} +export fn fn2222() void { + dest_end = 3; + _ = src_ptr133[3..dest_end]; +} +export fn fn2223() void { + dest_end = 1; + _ = src_ptr133[3..dest_end]; +} +export fn fn2224() void { + _ = src_ptr133[3..][0..2]; +} +export fn fn2225() void { + _ = src_ptr133[3..][0..3]; +} +export fn fn2226() void { + _ = src_ptr133[3..][0..1]; +} +export fn fn2227() void { + dest_len = 3; + _ = src_ptr133[3..][0..dest_len]; +} +export fn fn2228() void { + dest_len = 1; + _ = src_ptr133[3..][0..dest_len]; +} +export fn fn2229() void { + _ = src_ptr133[0..2 :1]; +} +export fn fn2230() void { + _ = src_ptr133[0..3 :1]; +} +export fn fn2231() void { + _ = src_ptr133[0..][0..2 :1]; +} +export fn fn2232() void { + _ = src_ptr133[0..][0..3 :1]; +} +export fn fn2233() void { + _ = src_ptr133[1..2 :1]; +} +export fn fn2234() void { + _ = src_ptr133[1..3 :1]; +} +export fn fn2235() void { + _ = src_ptr133[1..][0..2 :1]; +} +export fn fn2236() void { + _ = src_ptr133[1..][0..3 :1]; +} +export fn fn2237() void { + _ = src_ptr133[1..][0..1 :1]; +} +export fn fn2238() void { + _ = src_ptr133[3.. :1]; +} +export fn fn2239() void { + _ = src_ptr133[3..2 :1]; +} +export fn fn2240() void { + _ = src_ptr133[3..3 :1]; +} +export fn fn2241() void { + _ = src_ptr133[3..1 :1]; +} +export fn fn2242() void { + dest_end = 3; + _ = src_ptr133[3..dest_end :1]; +} +export fn fn2243() void { + dest_end = 1; + _ = src_ptr133[3..dest_end :1]; +} +export fn fn2244() void { + _ = src_ptr133[3..][0..2 :1]; +} +export fn fn2245() void { + _ = src_ptr133[3..][0..3 :1]; +} +export fn fn2246() void { + _ = src_ptr133[3..][0..1 :1]; +} +export fn fn2247() void { + dest_len = 3; + _ = src_ptr133[3..][0..dest_len :1]; +} +export fn fn2248() void { + dest_len = 1; + _ = src_ptr133[3..][0..dest_len :1]; +} +const src_mem92: [3]u8 = .{ 1, 1, 1 }; +var src_ptr134: *const [3]u8 = src_mem92[0..3]; +export fn fn2249() void { + _ = src_ptr134[1..][0..3]; +} +export fn fn2250() void { + _ = src_ptr134[3..2]; +} +export fn fn2251() void { + _ = src_ptr134[3..1]; +} +export fn fn2252() void { + _ = src_ptr134[3..][0..2]; +} +export fn fn2253() void { + _ = src_ptr134[3..][0..3]; +} +export fn fn2254() void { + _ = src_ptr134[3..][0..1]; +} +export fn fn2255() void { + _ = src_ptr134[0.. :1]; +} +export fn fn2256() void { + _ = src_ptr134[0..3 :1]; +} +export fn fn2257() void { + _ = src_ptr134[0..][0..3 :1]; +} +export fn fn2258() void { + _ = src_ptr134[1.. :1]; +} +export fn fn2259() void { + _ = src_ptr134[1..3 :1]; +} +export fn fn2260() void { + _ = src_ptr134[1..][0..2 :1]; +} +export fn fn2261() void { + _ = src_ptr134[1..][0..3 :1]; +} +export fn fn2262() void { + _ = src_ptr134[3.. :1]; +} +export fn fn2263() void { + _ = src_ptr134[3..2 :1]; +} +export fn fn2264() void { + _ = src_ptr134[3..3 :1]; +} +export fn fn2265() void { + _ = src_ptr134[3..1 :1]; +} +export fn fn2266() void { + dest_end = 3; + _ = src_ptr134[3..dest_end :1]; +} +export fn fn2267() void { + dest_end = 1; + _ = src_ptr134[3..dest_end :1]; +} +export fn fn2268() void { + _ = src_ptr134[3..][0..2 :1]; +} +export fn fn2269() void { + _ = src_ptr134[3..][0..3 :1]; +} +export fn fn2270() void { + _ = src_ptr134[3..][0..1 :1]; +} +export fn fn2271() void { + dest_len = 3; + _ = src_ptr134[3..][0..dest_len :1]; +} +export fn fn2272() void { + dest_len = 1; + _ = src_ptr134[3..][0..dest_len :1]; +} +const src_mem93: [3]u8 = .{ 1, 1, 0 }; +var src_ptr135: *const [2:0]u8 = src_mem93[0..2 :0]; +export fn fn2273() void { + _ = src_ptr135[1..][0..3]; +} +export fn fn2274() void { + _ = src_ptr135[3..]; +} +export fn fn2275() void { + _ = src_ptr135[3..2]; +} +export fn fn2276() void { + _ = src_ptr135[3..1]; +} +export fn fn2277() void { + _ = src_ptr135[3..][0..2]; +} +export fn fn2278() void { + _ = src_ptr135[3..][0..3]; +} +export fn fn2279() void { + _ = src_ptr135[3..][0..1]; +} +export fn fn2280() void { + _ = src_ptr135[0..3 :1]; +} +export fn fn2281() void { + _ = src_ptr135[0..][0..3 :1]; +} +export fn fn2282() void { + _ = src_ptr135[1..3 :1]; +} +export fn fn2283() void { + _ = src_ptr135[1..][0..2 :1]; +} +export fn fn2284() void { + _ = src_ptr135[1..][0..3 :1]; +} +export fn fn2285() void { + _ = src_ptr135[3.. :1]; +} +export fn fn2286() void { + _ = src_ptr135[3..2 :1]; +} +export fn fn2287() void { + _ = src_ptr135[3..3 :1]; +} +export fn fn2288() void { + _ = src_ptr135[3..1 :1]; +} +export fn fn2289() void { + dest_end = 3; + _ = src_ptr135[3..dest_end :1]; +} +export fn fn2290() void { + dest_end = 1; + _ = src_ptr135[3..dest_end :1]; +} +export fn fn2291() void { + _ = src_ptr135[3..][0..2 :1]; +} +export fn fn2292() void { + _ = src_ptr135[3..][0..3 :1]; +} +export fn fn2293() void { + _ = src_ptr135[3..][0..1 :1]; +} +export fn fn2294() void { + dest_len = 3; + _ = src_ptr135[3..][0..dest_len :1]; +} +export fn fn2295() void { + dest_len = 1; + _ = src_ptr135[3..][0..dest_len :1]; +} +const src_mem94: [1]u8 = .{1}; +var src_ptr136: *const [1]u8 = src_mem94[0..1]; +export fn fn2296() void { + _ = src_ptr136[0..2]; +} +export fn fn2297() void { + _ = src_ptr136[0..3]; +} +export fn fn2298() void { + _ = src_ptr136[0..][0..2]; +} +export fn fn2299() void { + _ = src_ptr136[0..][0..3]; +} +export fn fn2300() void { + _ = src_ptr136[1..2]; +} +export fn fn2301() void { + _ = src_ptr136[1..3]; +} +export fn fn2302() void { + _ = src_ptr136[1..][0..2]; +} +export fn fn2303() void { + _ = src_ptr136[1..][0..3]; +} +export fn fn2304() void { + _ = src_ptr136[1..][0..1]; +} +export fn fn2305() void { + _ = src_ptr136[3..]; +} +export fn fn2306() void { + _ = src_ptr136[3..2]; +} +export fn fn2307() void { + _ = src_ptr136[3..3]; +} +export fn fn2308() void { + _ = src_ptr136[3..1]; +} +export fn fn2309() void { + dest_end = 3; + _ = src_ptr136[3..dest_end]; +} +export fn fn2310() void { + dest_end = 1; + _ = src_ptr136[3..dest_end]; +} +export fn fn2311() void { + _ = src_ptr136[3..][0..2]; +} +export fn fn2312() void { + _ = src_ptr136[3..][0..3]; +} +export fn fn2313() void { + _ = src_ptr136[3..][0..1]; +} +export fn fn2314() void { + dest_len = 3; + _ = src_ptr136[3..][0..dest_len]; +} +export fn fn2315() void { + dest_len = 1; + _ = src_ptr136[3..][0..dest_len]; +} +export fn fn2316() void { + _ = src_ptr136[0.. :1]; +} +export fn fn2317() void { + _ = src_ptr136[0..2 :1]; +} +export fn fn2318() void { + _ = src_ptr136[0..3 :1]; +} +export fn fn2319() void { + _ = src_ptr136[0..1 :1]; +} +export fn fn2320() void { + _ = src_ptr136[0..][0..2 :1]; +} +export fn fn2321() void { + _ = src_ptr136[0..][0..3 :1]; +} +export fn fn2322() void { + _ = src_ptr136[0..][0..1 :1]; +} +export fn fn2323() void { + _ = src_ptr136[1.. :1]; +} +export fn fn2324() void { + _ = src_ptr136[1..2 :1]; +} +export fn fn2325() void { + _ = src_ptr136[1..3 :1]; +} +export fn fn2326() void { + _ = src_ptr136[1..1 :1]; +} +export fn fn2327() void { + dest_end = 3; + _ = src_ptr136[1..dest_end :1]; +} +export fn fn2328() void { + dest_end = 1; + _ = src_ptr136[1..dest_end :1]; +} +export fn fn2329() void { + _ = src_ptr136[1..][0..2 :1]; +} +export fn fn2330() void { + _ = src_ptr136[1..][0..3 :1]; +} +export fn fn2331() void { + _ = src_ptr136[1..][0..1 :1]; +} +export fn fn2332() void { + dest_len = 3; + _ = src_ptr136[1..][0..dest_len :1]; +} +export fn fn2333() void { + dest_len = 1; + _ = src_ptr136[1..][0..dest_len :1]; +} +export fn fn2334() void { + _ = src_ptr136[3.. :1]; +} +export fn fn2335() void { + _ = src_ptr136[3..2 :1]; +} +export fn fn2336() void { + _ = src_ptr136[3..3 :1]; +} +export fn fn2337() void { + _ = src_ptr136[3..1 :1]; +} +export fn fn2338() void { + dest_end = 3; + _ = src_ptr136[3..dest_end :1]; +} +export fn fn2339() void { + dest_end = 1; + _ = src_ptr136[3..dest_end :1]; +} +export fn fn2340() void { + _ = src_ptr136[3..][0..2 :1]; +} +export fn fn2341() void { + _ = src_ptr136[3..][0..3 :1]; +} +export fn fn2342() void { + _ = src_ptr136[3..][0..1 :1]; +} +export fn fn2343() void { + dest_len = 3; + _ = src_ptr136[3..][0..dest_len :1]; +} +export fn fn2344() void { + dest_len = 1; + _ = src_ptr136[3..][0..dest_len :1]; +} +const src_mem95: [1]u8 = .{0}; +var src_ptr137: *const [0:0]u8 = src_mem95[0..0 :0]; +export fn fn2345() void { + _ = src_ptr137[0..2]; +} +export fn fn2346() void { + _ = src_ptr137[0..3]; +} +export fn fn2347() void { + _ = src_ptr137[0..][0..2]; +} +export fn fn2348() void { + _ = src_ptr137[0..][0..3]; +} +export fn fn2349() void { + _ = src_ptr137[1..]; +} +export fn fn2350() void { + _ = src_ptr137[1..2]; +} +export fn fn2351() void { + _ = src_ptr137[1..3]; +} +export fn fn2352() void { + _ = src_ptr137[1..][0..2]; +} +export fn fn2353() void { + _ = src_ptr137[1..][0..3]; +} +export fn fn2354() void { + _ = src_ptr137[1..][0..1]; +} +export fn fn2355() void { + _ = src_ptr137[3..]; +} +export fn fn2356() void { + _ = src_ptr137[3..2]; +} +export fn fn2357() void { + _ = src_ptr137[3..3]; +} +export fn fn2358() void { + _ = src_ptr137[3..1]; +} +export fn fn2359() void { + dest_end = 3; + _ = src_ptr137[3..dest_end]; +} +export fn fn2360() void { + dest_end = 1; + _ = src_ptr137[3..dest_end]; +} +export fn fn2361() void { + _ = src_ptr137[3..][0..2]; +} +export fn fn2362() void { + _ = src_ptr137[3..][0..3]; +} +export fn fn2363() void { + _ = src_ptr137[3..][0..1]; +} +export fn fn2364() void { + dest_len = 3; + _ = src_ptr137[3..][0..dest_len]; +} +export fn fn2365() void { + dest_len = 1; + _ = src_ptr137[3..][0..dest_len]; +} +export fn fn2366() void { + _ = src_ptr137[0..2 :1]; +} +export fn fn2367() void { + _ = src_ptr137[0..3 :1]; +} +export fn fn2368() void { + _ = src_ptr137[0..1 :1]; +} +export fn fn2369() void { + _ = src_ptr137[0..][0..2 :1]; +} +export fn fn2370() void { + _ = src_ptr137[0..][0..3 :1]; +} +export fn fn2371() void { + _ = src_ptr137[0..][0..1 :1]; +} +export fn fn2372() void { + _ = src_ptr137[1.. :1]; +} +export fn fn2373() void { + _ = src_ptr137[1..2 :1]; +} +export fn fn2374() void { + _ = src_ptr137[1..3 :1]; +} +export fn fn2375() void { + _ = src_ptr137[1..1 :1]; +} +export fn fn2376() void { + dest_end = 3; + _ = src_ptr137[1..dest_end :1]; +} +export fn fn2377() void { + dest_end = 1; + _ = src_ptr137[1..dest_end :1]; +} +export fn fn2378() void { + _ = src_ptr137[1..][0..2 :1]; +} +export fn fn2379() void { + _ = src_ptr137[1..][0..3 :1]; +} +export fn fn2380() void { + _ = src_ptr137[1..][0..1 :1]; +} +export fn fn2381() void { + dest_len = 3; + _ = src_ptr137[1..][0..dest_len :1]; +} +export fn fn2382() void { + dest_len = 1; + _ = src_ptr137[1..][0..dest_len :1]; +} +export fn fn2383() void { + _ = src_ptr137[3.. :1]; +} +export fn fn2384() void { + _ = src_ptr137[3..2 :1]; +} +export fn fn2385() void { + _ = src_ptr137[3..3 :1]; +} +export fn fn2386() void { + _ = src_ptr137[3..1 :1]; +} +export fn fn2387() void { + dest_end = 3; + _ = src_ptr137[3..dest_end :1]; +} +export fn fn2388() void { + dest_end = 1; + _ = src_ptr137[3..dest_end :1]; +} +export fn fn2389() void { + _ = src_ptr137[3..][0..2 :1]; +} +export fn fn2390() void { + _ = src_ptr137[3..][0..3 :1]; +} +export fn fn2391() void { + _ = src_ptr137[3..][0..1 :1]; +} +export fn fn2392() void { + dest_len = 3; + _ = src_ptr137[3..][0..dest_len :1]; +} +export fn fn2393() void { + dest_len = 1; + _ = src_ptr137[3..][0..dest_len :1]; +} +const src_mem96: [2]u8 = .{ 1, 1 }; +const src_ptr138: []const u8 = src_mem96[0..2]; +comptime { + _ = src_ptr138[0..3]; +} +comptime { + _ = src_ptr138[0..][0..3]; +} +comptime { + _ = src_ptr138[1..3]; +} +comptime { + _ = src_ptr138[1..][0..2]; +} +comptime { + _ = src_ptr138[1..][0..3]; +} +comptime { + _ = src_ptr138[3..]; +} +comptime { + _ = src_ptr138[3..2]; +} +comptime { + _ = src_ptr138[3..3]; +} +comptime { + _ = src_ptr138[3..1]; +} +export fn fn2394() void { + dest_end = 3; + _ = src_ptr138[3..dest_end]; +} +export fn fn2395() void { + dest_end = 1; + _ = src_ptr138[3..dest_end]; +} +comptime { + _ = src_ptr138[3..][0..2]; +} +comptime { + _ = src_ptr138[3..][0..3]; +} +comptime { + _ = src_ptr138[3..][0..1]; +} +export fn fn2396() void { + dest_len = 3; + _ = src_ptr138[3..][0..dest_len]; +} +export fn fn2397() void { + dest_len = 1; + _ = src_ptr138[3..][0..dest_len]; +} +comptime { + _ = src_ptr138[0.. :1]; +} +comptime { + _ = src_ptr138[0..2 :1]; +} +comptime { + _ = src_ptr138[0..3 :1]; +} +comptime { + _ = src_ptr138[0..][0..2 :1]; +} +comptime { + _ = src_ptr138[0..][0..3 :1]; +} +comptime { + _ = src_ptr138[1.. :1]; +} +comptime { + _ = src_ptr138[1..2 :1]; +} +comptime { + _ = src_ptr138[1..3 :1]; +} +comptime { + _ = src_ptr138[1..][0..2 :1]; +} +comptime { + _ = src_ptr138[1..][0..3 :1]; +} +comptime { + _ = src_ptr138[1..][0..1 :1]; +} +comptime { + _ = src_ptr138[3.. :1]; +} +comptime { + _ = src_ptr138[3..2 :1]; +} +comptime { + _ = src_ptr138[3..3 :1]; +} +comptime { + _ = src_ptr138[3..1 :1]; +} +export fn fn2398() void { + dest_end = 3; + _ = src_ptr138[3..dest_end :1]; +} +export fn fn2399() void { + dest_end = 1; + _ = src_ptr138[3..dest_end :1]; +} +comptime { + _ = src_ptr138[3..][0..2 :1]; +} +comptime { + _ = src_ptr138[3..][0..3 :1]; +} +comptime { + _ = src_ptr138[3..][0..1 :1]; +} +export fn fn2400() void { + dest_len = 3; + _ = src_ptr138[3..][0..dest_len :1]; +} +export fn fn2401() void { + dest_len = 1; + _ = src_ptr138[3..][0..dest_len :1]; +} +const src_mem97: [2]u8 = .{ 1, 0 }; +const src_ptr139: [:0]const u8 = src_mem97[0..1 :0]; +comptime { + _ = src_ptr139[0..3]; +} +comptime { + _ = src_ptr139[0..][0..3]; +} +comptime { + _ = src_ptr139[1..3]; +} +comptime { + _ = src_ptr139[1..][0..2]; +} +comptime { + _ = src_ptr139[1..][0..3]; +} +comptime { + _ = src_ptr139[3..]; +} +comptime { + _ = src_ptr139[3..2]; +} +comptime { + _ = src_ptr139[3..3]; +} +comptime { + _ = src_ptr139[3..1]; +} +export fn fn2402() void { + dest_end = 3; + _ = src_ptr139[3..dest_end]; +} +export fn fn2403() void { + dest_end = 1; + _ = src_ptr139[3..dest_end]; +} +comptime { + _ = src_ptr139[3..][0..2]; +} +comptime { + _ = src_ptr139[3..][0..3]; +} +comptime { + _ = src_ptr139[3..][0..1]; +} +export fn fn2404() void { + dest_len = 3; + _ = src_ptr139[3..][0..dest_len]; +} +export fn fn2405() void { + dest_len = 1; + _ = src_ptr139[3..][0..dest_len]; +} +comptime { + _ = src_ptr139[0.. :1]; +} +comptime { + _ = src_ptr139[0..2 :1]; +} +comptime { + _ = src_ptr139[0..3 :1]; +} +comptime { + _ = src_ptr139[0..1 :1]; +} +comptime { + _ = src_ptr139[0..][0..2 :1]; +} +comptime { + _ = src_ptr139[0..][0..3 :1]; +} +comptime { + _ = src_ptr139[0..][0..1 :1]; +} +comptime { + _ = src_ptr139[1.. :1]; +} +comptime { + _ = src_ptr139[1..2 :1]; +} +comptime { + _ = src_ptr139[1..3 :1]; +} +comptime { + _ = src_ptr139[1..1 :1]; +} +comptime { + _ = src_ptr139[1..][0..2 :1]; +} +comptime { + _ = src_ptr139[1..][0..3 :1]; +} +comptime { + _ = src_ptr139[1..][0..1 :1]; +} +comptime { + _ = src_ptr139[3.. :1]; +} +comptime { + _ = src_ptr139[3..2 :1]; +} +comptime { + _ = src_ptr139[3..3 :1]; +} +comptime { + _ = src_ptr139[3..1 :1]; +} +export fn fn2406() void { + dest_end = 3; + _ = src_ptr139[3..dest_end :1]; +} +export fn fn2407() void { + dest_end = 1; + _ = src_ptr139[3..dest_end :1]; +} +comptime { + _ = src_ptr139[3..][0..2 :1]; +} +comptime { + _ = src_ptr139[3..][0..3 :1]; +} +comptime { + _ = src_ptr139[3..][0..1 :1]; +} +export fn fn2408() void { + dest_len = 3; + _ = src_ptr139[3..][0..dest_len :1]; +} +export fn fn2409() void { + dest_len = 1; + _ = src_ptr139[3..][0..dest_len :1]; +} +const src_mem98: [3]u8 = .{ 1, 1, 1 }; +const src_ptr140: []const u8 = src_mem98[0..3]; +comptime { + _ = src_ptr140[1..][0..3]; +} +comptime { + _ = src_ptr140[3..2]; +} +comptime { + _ = src_ptr140[3..1]; +} +comptime { + _ = src_ptr140[3..][0..2]; +} +comptime { + _ = src_ptr140[3..][0..3]; +} +comptime { + _ = src_ptr140[3..][0..1]; +} +comptime { + _ = src_ptr140[0.. :1]; +} +comptime { + _ = src_ptr140[0..3 :1]; +} +comptime { + _ = src_ptr140[0..][0..3 :1]; +} +comptime { + _ = src_ptr140[1.. :1]; +} +comptime { + _ = src_ptr140[1..3 :1]; +} +comptime { + _ = src_ptr140[1..][0..2 :1]; +} +comptime { + _ = src_ptr140[1..][0..3 :1]; +} +comptime { + _ = src_ptr140[3.. :1]; +} +comptime { + _ = src_ptr140[3..2 :1]; +} +comptime { + _ = src_ptr140[3..3 :1]; +} +comptime { + _ = src_ptr140[3..1 :1]; +} +export fn fn2410() void { + dest_end = 3; + _ = src_ptr140[3..dest_end :1]; +} +export fn fn2411() void { + dest_end = 1; + _ = src_ptr140[3..dest_end :1]; +} +comptime { + _ = src_ptr140[3..][0..2 :1]; +} +comptime { + _ = src_ptr140[3..][0..3 :1]; +} +comptime { + _ = src_ptr140[3..][0..1 :1]; +} +export fn fn2412() void { + dest_len = 3; + _ = src_ptr140[3..][0..dest_len :1]; +} +export fn fn2413() void { + dest_len = 1; + _ = src_ptr140[3..][0..dest_len :1]; +} +const src_mem99: [3]u8 = .{ 1, 1, 0 }; +const src_ptr141: [:0]const u8 = src_mem99[0..2 :0]; +comptime { + _ = src_ptr141[1..][0..3]; +} +comptime { + _ = src_ptr141[3..]; +} +comptime { + _ = src_ptr141[3..2]; +} +comptime { + _ = src_ptr141[3..1]; +} +comptime { + _ = src_ptr141[3..][0..2]; +} +comptime { + _ = src_ptr141[3..][0..3]; +} +comptime { + _ = src_ptr141[3..][0..1]; +} +comptime { + _ = src_ptr141[0.. :1]; +} +comptime { + _ = src_ptr141[0..2 :1]; +} +comptime { + _ = src_ptr141[0..3 :1]; +} +comptime { + _ = src_ptr141[0..][0..2 :1]; +} +comptime { + _ = src_ptr141[0..][0..3 :1]; +} +comptime { + _ = src_ptr141[1.. :1]; +} +comptime { + _ = src_ptr141[1..2 :1]; +} +comptime { + _ = src_ptr141[1..3 :1]; +} +comptime { + _ = src_ptr141[1..][0..2 :1]; +} +comptime { + _ = src_ptr141[1..][0..3 :1]; +} +comptime { + _ = src_ptr141[1..][0..1 :1]; +} +comptime { + _ = src_ptr141[3.. :1]; +} +comptime { + _ = src_ptr141[3..2 :1]; +} +comptime { + _ = src_ptr141[3..3 :1]; +} +comptime { + _ = src_ptr141[3..1 :1]; +} +export fn fn2414() void { + dest_end = 3; + _ = src_ptr141[3..dest_end :1]; +} +export fn fn2415() void { + dest_end = 1; + _ = src_ptr141[3..dest_end :1]; +} +comptime { + _ = src_ptr141[3..][0..2 :1]; +} +comptime { + _ = src_ptr141[3..][0..3 :1]; +} +comptime { + _ = src_ptr141[3..][0..1 :1]; +} +export fn fn2416() void { + dest_len = 3; + _ = src_ptr141[3..][0..dest_len :1]; +} +export fn fn2417() void { + dest_len = 1; + _ = src_ptr141[3..][0..dest_len :1]; +} +const src_mem100: [1]u8 = .{1}; +const src_ptr142: []const u8 = src_mem100[0..1]; +comptime { + _ = src_ptr142[0..2]; +} +comptime { + _ = src_ptr142[0..3]; +} +comptime { + _ = src_ptr142[0..][0..2]; +} +comptime { + _ = src_ptr142[0..][0..3]; +} +comptime { + _ = src_ptr142[1..2]; +} +comptime { + _ = src_ptr142[1..3]; +} +comptime { + _ = src_ptr142[1..][0..2]; +} +comptime { + _ = src_ptr142[1..][0..3]; +} +comptime { + _ = src_ptr142[1..][0..1]; +} +comptime { + _ = src_ptr142[3..]; +} +comptime { + _ = src_ptr142[3..2]; +} +comptime { + _ = src_ptr142[3..3]; +} +comptime { + _ = src_ptr142[3..1]; +} +export fn fn2418() void { + dest_end = 3; + _ = src_ptr142[3..dest_end]; +} +export fn fn2419() void { + dest_end = 1; + _ = src_ptr142[3..dest_end]; +} +comptime { + _ = src_ptr142[3..][0..2]; +} +comptime { + _ = src_ptr142[3..][0..3]; +} +comptime { + _ = src_ptr142[3..][0..1]; +} +export fn fn2420() void { + dest_len = 3; + _ = src_ptr142[3..][0..dest_len]; +} +export fn fn2421() void { + dest_len = 1; + _ = src_ptr142[3..][0..dest_len]; +} +comptime { + _ = src_ptr142[0.. :1]; +} +comptime { + _ = src_ptr142[0..2 :1]; +} +comptime { + _ = src_ptr142[0..3 :1]; +} +comptime { + _ = src_ptr142[0..1 :1]; +} +comptime { + _ = src_ptr142[0..][0..2 :1]; +} +comptime { + _ = src_ptr142[0..][0..3 :1]; +} +comptime { + _ = src_ptr142[0..][0..1 :1]; +} +comptime { + _ = src_ptr142[1.. :1]; +} +comptime { + _ = src_ptr142[1..2 :1]; +} +comptime { + _ = src_ptr142[1..3 :1]; +} +comptime { + _ = src_ptr142[1..1 :1]; +} +export fn fn2422() void { + dest_end = 3; + _ = src_ptr142[1..dest_end :1]; +} +export fn fn2423() void { + dest_end = 1; + _ = src_ptr142[1..dest_end :1]; +} +comptime { + _ = src_ptr142[1..][0..2 :1]; +} +comptime { + _ = src_ptr142[1..][0..3 :1]; +} +comptime { + _ = src_ptr142[1..][0..1 :1]; +} +export fn fn2424() void { + dest_len = 3; + _ = src_ptr142[1..][0..dest_len :1]; +} +export fn fn2425() void { + dest_len = 1; + _ = src_ptr142[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr142[3.. :1]; +} +comptime { + _ = src_ptr142[3..2 :1]; +} +comptime { + _ = src_ptr142[3..3 :1]; +} +comptime { + _ = src_ptr142[3..1 :1]; +} +export fn fn2426() void { + dest_end = 3; + _ = src_ptr142[3..dest_end :1]; +} +export fn fn2427() void { + dest_end = 1; + _ = src_ptr142[3..dest_end :1]; +} +comptime { + _ = src_ptr142[3..][0..2 :1]; +} +comptime { + _ = src_ptr142[3..][0..3 :1]; +} +comptime { + _ = src_ptr142[3..][0..1 :1]; +} +export fn fn2428() void { + dest_len = 3; + _ = src_ptr142[3..][0..dest_len :1]; +} +export fn fn2429() void { + dest_len = 1; + _ = src_ptr142[3..][0..dest_len :1]; +} +const src_mem101: [1]u8 = .{0}; +const src_ptr143: [:0]const u8 = src_mem101[0..0 :0]; +comptime { + _ = src_ptr143[0..2]; +} +comptime { + _ = src_ptr143[0..3]; +} +comptime { + _ = src_ptr143[0..][0..2]; +} +comptime { + _ = src_ptr143[0..][0..3]; +} +comptime { + _ = src_ptr143[1..]; +} +comptime { + _ = src_ptr143[1..2]; +} +comptime { + _ = src_ptr143[1..3]; +} +comptime { + _ = src_ptr143[1..][0..2]; +} +comptime { + _ = src_ptr143[1..][0..3]; +} +comptime { + _ = src_ptr143[1..][0..1]; +} +comptime { + _ = src_ptr143[3..]; +} +comptime { + _ = src_ptr143[3..2]; +} +comptime { + _ = src_ptr143[3..3]; +} +comptime { + _ = src_ptr143[3..1]; +} +export fn fn2430() void { + dest_end = 3; + _ = src_ptr143[3..dest_end]; +} +export fn fn2431() void { + dest_end = 1; + _ = src_ptr143[3..dest_end]; +} +comptime { + _ = src_ptr143[3..][0..2]; +} +comptime { + _ = src_ptr143[3..][0..3]; +} +comptime { + _ = src_ptr143[3..][0..1]; +} +export fn fn2432() void { + dest_len = 3; + _ = src_ptr143[3..][0..dest_len]; +} +export fn fn2433() void { + dest_len = 1; + _ = src_ptr143[3..][0..dest_len]; +} +comptime { + _ = src_ptr143[0.. :1]; +} +comptime { + _ = src_ptr143[0..2 :1]; +} +comptime { + _ = src_ptr143[0..3 :1]; +} +comptime { + _ = src_ptr143[0..1 :1]; +} +comptime { + _ = src_ptr143[0..][0..2 :1]; +} +comptime { + _ = src_ptr143[0..][0..3 :1]; +} +comptime { + _ = src_ptr143[0..][0..1 :1]; +} +comptime { + _ = src_ptr143[1.. :1]; +} +comptime { + _ = src_ptr143[1..2 :1]; +} +comptime { + _ = src_ptr143[1..3 :1]; +} +comptime { + _ = src_ptr143[1..1 :1]; +} +export fn fn2434() void { + dest_end = 3; + _ = src_ptr143[1..dest_end :1]; +} +export fn fn2435() void { + dest_end = 1; + _ = src_ptr143[1..dest_end :1]; +} +comptime { + _ = src_ptr143[1..][0..2 :1]; +} +comptime { + _ = src_ptr143[1..][0..3 :1]; +} +comptime { + _ = src_ptr143[1..][0..1 :1]; +} +export fn fn2436() void { + dest_len = 3; + _ = src_ptr143[1..][0..dest_len :1]; +} +export fn fn2437() void { + dest_len = 1; + _ = src_ptr143[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr143[3.. :1]; +} +comptime { + _ = src_ptr143[3..2 :1]; +} +comptime { + _ = src_ptr143[3..3 :1]; +} +comptime { + _ = src_ptr143[3..1 :1]; +} +export fn fn2438() void { + dest_end = 3; + _ = src_ptr143[3..dest_end :1]; +} +export fn fn2439() void { + dest_end = 1; + _ = src_ptr143[3..dest_end :1]; +} +comptime { + _ = src_ptr143[3..][0..2 :1]; +} +comptime { + _ = src_ptr143[3..][0..3 :1]; +} +comptime { + _ = src_ptr143[3..][0..1 :1]; +} +export fn fn2440() void { + dest_len = 3; + _ = src_ptr143[3..][0..dest_len :1]; +} +export fn fn2441() void { + dest_len = 1; + _ = src_ptr143[3..][0..dest_len :1]; +} +const src_mem102: [2]u8 = .{ 1, 1 }; +var src_ptr144: []const u8 = src_mem102[0..2]; +export fn fn2442() void { + _ = src_ptr144[3..2]; +} +export fn fn2443() void { + _ = src_ptr144[3..1]; +} +export fn fn2444() void { + _ = src_ptr144[0.. :1]; +} +export fn fn2445() void { + _ = src_ptr144[1.. :1]; +} +export fn fn2446() void { + _ = src_ptr144[3.. :1]; +} +export fn fn2447() void { + _ = src_ptr144[3..2 :1]; +} +export fn fn2448() void { + _ = src_ptr144[3..1 :1]; +} +const src_mem103: [2]u8 = .{ 1, 0 }; +var src_ptr145: [:0]const u8 = src_mem103[0..1 :0]; +export fn fn2449() void { + _ = src_ptr145[3..2]; +} +export fn fn2450() void { + _ = src_ptr145[3..1]; +} +export fn fn2451() void { + _ = src_ptr145[3..2 :1]; +} +export fn fn2452() void { + _ = src_ptr145[3..1 :1]; +} +const src_mem104: [3]u8 = .{ 1, 1, 1 }; +var src_ptr146: []const u8 = src_mem104[0..3]; +export fn fn2453() void { + _ = src_ptr146[3..2]; +} +export fn fn2454() void { + _ = src_ptr146[3..1]; +} +export fn fn2455() void { + _ = src_ptr146[0.. :1]; +} +export fn fn2456() void { + _ = src_ptr146[1.. :1]; +} +export fn fn2457() void { + _ = src_ptr146[3.. :1]; +} +export fn fn2458() void { + _ = src_ptr146[3..2 :1]; +} +export fn fn2459() void { + _ = src_ptr146[3..1 :1]; +} +const src_mem105: [3]u8 = .{ 1, 1, 0 }; +var src_ptr147: [:0]const u8 = src_mem105[0..2 :0]; +export fn fn2460() void { + _ = src_ptr147[3..2]; +} +export fn fn2461() void { + _ = src_ptr147[3..1]; +} +export fn fn2462() void { + _ = src_ptr147[3..2 :1]; +} +export fn fn2463() void { + _ = src_ptr147[3..1 :1]; +} +const src_mem106: [1]u8 = .{1}; +var src_ptr148: []const u8 = src_mem106[0..1]; +export fn fn2464() void { + _ = src_ptr148[3..2]; +} +export fn fn2465() void { + _ = src_ptr148[3..1]; +} +export fn fn2466() void { + _ = src_ptr148[0.. :1]; +} +export fn fn2467() void { + _ = src_ptr148[1.. :1]; +} +export fn fn2468() void { + _ = src_ptr148[3.. :1]; +} +export fn fn2469() void { + _ = src_ptr148[3..2 :1]; +} +export fn fn2470() void { + _ = src_ptr148[3..1 :1]; +} +const src_mem107: [1]u8 = .{0}; +var src_ptr149: [:0]const u8 = src_mem107[0..0 :0]; +export fn fn2471() void { + _ = src_ptr149[3..2]; +} +export fn fn2472() void { + _ = src_ptr149[3..1]; +} +export fn fn2473() void { + _ = src_ptr149[3..2 :1]; +} +export fn fn2474() void { + _ = src_ptr149[3..1 :1]; +} +const src_mem108: [2]u8 = .{ 1, 1 }; +const src_ptr150: [*]const u8 = @ptrCast(&src_mem108); +comptime { + _ = src_ptr150[0..3]; +} +comptime { + _ = src_ptr150[0..][0..3]; +} +comptime { + _ = src_ptr150[1..3]; +} +comptime { + _ = src_ptr150[1..][0..2]; +} +comptime { + _ = src_ptr150[1..][0..3]; +} +comptime { + _ = src_ptr150[3..]; +} +comptime { + _ = src_ptr150[3..2]; +} +comptime { + _ = src_ptr150[3..3]; +} +comptime { + _ = src_ptr150[3..1]; +} +export fn fn2475() void { + dest_end = 3; + _ = src_ptr150[3..dest_end]; +} +export fn fn2476() void { + dest_end = 1; + _ = src_ptr150[3..dest_end]; +} +comptime { + _ = src_ptr150[3..][0..2]; +} +comptime { + _ = src_ptr150[3..][0..3]; +} +comptime { + _ = src_ptr150[3..][0..1]; +} +export fn fn2477() void { + dest_len = 3; + _ = src_ptr150[3..][0..dest_len]; +} +export fn fn2478() void { + dest_len = 1; + _ = src_ptr150[3..][0..dest_len]; +} +comptime { + _ = src_ptr150[0..2 :1]; +} +comptime { + _ = src_ptr150[0..3 :1]; +} +comptime { + _ = src_ptr150[0..][0..2 :1]; +} +comptime { + _ = src_ptr150[0..][0..3 :1]; +} +comptime { + _ = src_ptr150[1..2 :1]; +} +comptime { + _ = src_ptr150[1..3 :1]; +} +comptime { + _ = src_ptr150[1..][0..2 :1]; +} +comptime { + _ = src_ptr150[1..][0..3 :1]; +} +comptime { + _ = src_ptr150[1..][0..1 :1]; +} +comptime { + _ = src_ptr150[3.. :1]; +} +comptime { + _ = src_ptr150[3..2 :1]; +} +comptime { + _ = src_ptr150[3..3 :1]; +} +comptime { + _ = src_ptr150[3..1 :1]; +} +export fn fn2479() void { + dest_end = 3; + _ = src_ptr150[3..dest_end :1]; +} +export fn fn2480() void { + dest_end = 1; + _ = src_ptr150[3..dest_end :1]; +} +comptime { + _ = src_ptr150[3..][0..2 :1]; +} +comptime { + _ = src_ptr150[3..][0..3 :1]; +} +comptime { + _ = src_ptr150[3..][0..1 :1]; +} +export fn fn2481() void { + dest_len = 3; + _ = src_ptr150[3..][0..dest_len :1]; +} +export fn fn2482() void { + dest_len = 1; + _ = src_ptr150[3..][0..dest_len :1]; +} +const src_mem109: [2]u8 = .{ 1, 0 }; +const src_ptr151: [*:0]const u8 = @ptrCast(&src_mem109); +comptime { + _ = src_ptr151[0..3]; +} +comptime { + _ = src_ptr151[0..][0..3]; +} +comptime { + _ = src_ptr151[1..3]; +} +comptime { + _ = src_ptr151[1..][0..2]; +} +comptime { + _ = src_ptr151[1..][0..3]; +} +comptime { + _ = src_ptr151[3..]; +} +comptime { + _ = src_ptr151[3..2]; +} +comptime { + _ = src_ptr151[3..3]; +} +comptime { + _ = src_ptr151[3..1]; +} +export fn fn2483() void { + dest_end = 3; + _ = src_ptr151[3..dest_end]; +} +export fn fn2484() void { + dest_end = 1; + _ = src_ptr151[3..dest_end]; +} +comptime { + _ = src_ptr151[3..][0..2]; +} +comptime { + _ = src_ptr151[3..][0..3]; +} +comptime { + _ = src_ptr151[3..][0..1]; +} +export fn fn2485() void { + dest_len = 3; + _ = src_ptr151[3..][0..dest_len]; +} +export fn fn2486() void { + dest_len = 1; + _ = src_ptr151[3..][0..dest_len]; +} +comptime { + _ = src_ptr151[0..2 :1]; +} +comptime { + _ = src_ptr151[0..3 :1]; +} +comptime { + _ = src_ptr151[0..1 :1]; +} +comptime { + _ = src_ptr151[0..][0..2 :1]; +} +comptime { + _ = src_ptr151[0..][0..3 :1]; +} +comptime { + _ = src_ptr151[0..][0..1 :1]; +} +comptime { + _ = src_ptr151[1..2 :1]; +} +comptime { + _ = src_ptr151[1..3 :1]; +} +comptime { + _ = src_ptr151[1..1 :1]; +} +comptime { + _ = src_ptr151[1..][0..2 :1]; +} +comptime { + _ = src_ptr151[1..][0..3 :1]; +} +comptime { + _ = src_ptr151[1..][0..1 :1]; +} +comptime { + _ = src_ptr151[3.. :1]; +} +comptime { + _ = src_ptr151[3..2 :1]; +} +comptime { + _ = src_ptr151[3..3 :1]; +} +comptime { + _ = src_ptr151[3..1 :1]; +} +export fn fn2487() void { + dest_end = 3; + _ = src_ptr151[3..dest_end :1]; +} +export fn fn2488() void { + dest_end = 1; + _ = src_ptr151[3..dest_end :1]; +} +comptime { + _ = src_ptr151[3..][0..2 :1]; +} +comptime { + _ = src_ptr151[3..][0..3 :1]; +} +comptime { + _ = src_ptr151[3..][0..1 :1]; +} +export fn fn2489() void { + dest_len = 3; + _ = src_ptr151[3..][0..dest_len :1]; +} +export fn fn2490() void { + dest_len = 1; + _ = src_ptr151[3..][0..dest_len :1]; +} +const src_mem110: [3]u8 = .{ 1, 1, 1 }; +const src_ptr152: [*]const u8 = @ptrCast(&src_mem110); +comptime { + _ = src_ptr152[1..][0..3]; +} +comptime { + _ = src_ptr152[3..2]; +} +comptime { + _ = src_ptr152[3..1]; +} +comptime { + _ = src_ptr152[3..][0..2]; +} +comptime { + _ = src_ptr152[3..][0..3]; +} +comptime { + _ = src_ptr152[3..][0..1]; +} +comptime { + _ = src_ptr152[0..3 :1]; +} +comptime { + _ = src_ptr152[0..][0..3 :1]; +} +comptime { + _ = src_ptr152[1..3 :1]; +} +comptime { + _ = src_ptr152[1..][0..2 :1]; +} +comptime { + _ = src_ptr152[1..][0..3 :1]; +} +comptime { + _ = src_ptr152[3.. :1]; +} +comptime { + _ = src_ptr152[3..2 :1]; +} +comptime { + _ = src_ptr152[3..3 :1]; +} +comptime { + _ = src_ptr152[3..1 :1]; +} +export fn fn2491() void { + dest_end = 3; + _ = src_ptr152[3..dest_end :1]; +} +export fn fn2492() void { + dest_end = 1; + _ = src_ptr152[3..dest_end :1]; +} +comptime { + _ = src_ptr152[3..][0..2 :1]; +} +comptime { + _ = src_ptr152[3..][0..3 :1]; +} +comptime { + _ = src_ptr152[3..][0..1 :1]; +} +export fn fn2493() void { + dest_len = 3; + _ = src_ptr152[3..][0..dest_len :1]; +} +export fn fn2494() void { + dest_len = 1; + _ = src_ptr152[3..][0..dest_len :1]; +} +const src_mem111: [3]u8 = .{ 1, 1, 0 }; +const src_ptr153: [*:0]const u8 = @ptrCast(&src_mem111); +comptime { + _ = src_ptr153[1..][0..3]; +} +comptime { + _ = src_ptr153[3..2]; +} +comptime { + _ = src_ptr153[3..1]; +} +comptime { + _ = src_ptr153[3..][0..2]; +} +comptime { + _ = src_ptr153[3..][0..3]; +} +comptime { + _ = src_ptr153[3..][0..1]; +} +comptime { + _ = src_ptr153[0..2 :1]; +} +comptime { + _ = src_ptr153[0..3 :1]; +} +comptime { + _ = src_ptr153[0..][0..2 :1]; +} +comptime { + _ = src_ptr153[0..][0..3 :1]; +} +comptime { + _ = src_ptr153[1..2 :1]; +} +comptime { + _ = src_ptr153[1..3 :1]; +} +comptime { + _ = src_ptr153[1..][0..2 :1]; +} +comptime { + _ = src_ptr153[1..][0..3 :1]; +} +comptime { + _ = src_ptr153[1..][0..1 :1]; +} +comptime { + _ = src_ptr153[3.. :1]; +} +comptime { + _ = src_ptr153[3..2 :1]; +} +comptime { + _ = src_ptr153[3..3 :1]; +} +comptime { + _ = src_ptr153[3..1 :1]; +} +export fn fn2495() void { + dest_end = 3; + _ = src_ptr153[3..dest_end :1]; +} +export fn fn2496() void { + dest_end = 1; + _ = src_ptr153[3..dest_end :1]; +} +comptime { + _ = src_ptr153[3..][0..2 :1]; +} +comptime { + _ = src_ptr153[3..][0..3 :1]; +} +comptime { + _ = src_ptr153[3..][0..1 :1]; +} +export fn fn2497() void { + dest_len = 3; + _ = src_ptr153[3..][0..dest_len :1]; +} +export fn fn2498() void { + dest_len = 1; + _ = src_ptr153[3..][0..dest_len :1]; +} +const src_mem112: [1]u8 = .{1}; +const src_ptr154: [*]const u8 = @ptrCast(&src_mem112); +comptime { + _ = src_ptr154[0..2]; +} +comptime { + _ = src_ptr154[0..3]; +} +comptime { + _ = src_ptr154[0..][0..2]; +} +comptime { + _ = src_ptr154[0..][0..3]; +} +comptime { + _ = src_ptr154[1..2]; +} +comptime { + _ = src_ptr154[1..3]; +} +comptime { + _ = src_ptr154[1..][0..2]; +} +comptime { + _ = src_ptr154[1..][0..3]; +} +comptime { + _ = src_ptr154[1..][0..1]; +} +comptime { + _ = src_ptr154[3..]; +} +comptime { + _ = src_ptr154[3..2]; +} +comptime { + _ = src_ptr154[3..3]; +} +comptime { + _ = src_ptr154[3..1]; +} +export fn fn2499() void { + dest_end = 3; + _ = src_ptr154[3..dest_end]; +} +export fn fn2500() void { + dest_end = 1; + _ = src_ptr154[3..dest_end]; +} +comptime { + _ = src_ptr154[3..][0..2]; +} +comptime { + _ = src_ptr154[3..][0..3]; +} +comptime { + _ = src_ptr154[3..][0..1]; +} +export fn fn2501() void { + dest_len = 3; + _ = src_ptr154[3..][0..dest_len]; +} +export fn fn2502() void { + dest_len = 1; + _ = src_ptr154[3..][0..dest_len]; +} +comptime { + _ = src_ptr154[0..2 :1]; +} +comptime { + _ = src_ptr154[0..3 :1]; +} +comptime { + _ = src_ptr154[0..1 :1]; +} +comptime { + _ = src_ptr154[0..][0..2 :1]; +} +comptime { + _ = src_ptr154[0..][0..3 :1]; +} +comptime { + _ = src_ptr154[0..][0..1 :1]; +} +comptime { + _ = src_ptr154[1.. :1]; +} +comptime { + _ = src_ptr154[1..2 :1]; +} +comptime { + _ = src_ptr154[1..3 :1]; +} +comptime { + _ = src_ptr154[1..1 :1]; +} +export fn fn2503() void { + dest_end = 3; + _ = src_ptr154[1..dest_end :1]; +} +export fn fn2504() void { + dest_end = 1; + _ = src_ptr154[1..dest_end :1]; +} +comptime { + _ = src_ptr154[1..][0..2 :1]; +} +comptime { + _ = src_ptr154[1..][0..3 :1]; +} +comptime { + _ = src_ptr154[1..][0..1 :1]; +} +export fn fn2505() void { + dest_len = 3; + _ = src_ptr154[1..][0..dest_len :1]; +} +export fn fn2506() void { + dest_len = 1; + _ = src_ptr154[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr154[3.. :1]; +} +comptime { + _ = src_ptr154[3..2 :1]; +} +comptime { + _ = src_ptr154[3..3 :1]; +} +comptime { + _ = src_ptr154[3..1 :1]; +} +export fn fn2507() void { + dest_end = 3; + _ = src_ptr154[3..dest_end :1]; +} +export fn fn2508() void { + dest_end = 1; + _ = src_ptr154[3..dest_end :1]; +} +comptime { + _ = src_ptr154[3..][0..2 :1]; +} +comptime { + _ = src_ptr154[3..][0..3 :1]; +} +comptime { + _ = src_ptr154[3..][0..1 :1]; +} +export fn fn2509() void { + dest_len = 3; + _ = src_ptr154[3..][0..dest_len :1]; +} +export fn fn2510() void { + dest_len = 1; + _ = src_ptr154[3..][0..dest_len :1]; +} +const src_mem113: [1]u8 = .{0}; +const src_ptr155: [*:0]const u8 = @ptrCast(&src_mem113); +comptime { + _ = src_ptr155[0..2]; +} +comptime { + _ = src_ptr155[0..3]; +} +comptime { + _ = src_ptr155[0..][0..2]; +} +comptime { + _ = src_ptr155[0..][0..3]; +} +comptime { + _ = src_ptr155[1..2]; +} +comptime { + _ = src_ptr155[1..3]; +} +comptime { + _ = src_ptr155[1..][0..2]; +} +comptime { + _ = src_ptr155[1..][0..3]; +} +comptime { + _ = src_ptr155[1..][0..1]; +} +comptime { + _ = src_ptr155[3..]; +} +comptime { + _ = src_ptr155[3..2]; +} +comptime { + _ = src_ptr155[3..3]; +} +comptime { + _ = src_ptr155[3..1]; +} +export fn fn2511() void { + dest_end = 3; + _ = src_ptr155[3..dest_end]; +} +export fn fn2512() void { + dest_end = 1; + _ = src_ptr155[3..dest_end]; +} +comptime { + _ = src_ptr155[3..][0..2]; +} +comptime { + _ = src_ptr155[3..][0..3]; +} +comptime { + _ = src_ptr155[3..][0..1]; +} +export fn fn2513() void { + dest_len = 3; + _ = src_ptr155[3..][0..dest_len]; +} +export fn fn2514() void { + dest_len = 1; + _ = src_ptr155[3..][0..dest_len]; +} +comptime { + _ = src_ptr155[0..2 :1]; +} +comptime { + _ = src_ptr155[0..3 :1]; +} +comptime { + _ = src_ptr155[0..1 :1]; +} +comptime { + _ = src_ptr155[0..][0..2 :1]; +} +comptime { + _ = src_ptr155[0..][0..3 :1]; +} +comptime { + _ = src_ptr155[0..][0..1 :1]; +} +comptime { + _ = src_ptr155[1.. :1]; +} +comptime { + _ = src_ptr155[1..2 :1]; +} +comptime { + _ = src_ptr155[1..3 :1]; +} +comptime { + _ = src_ptr155[1..1 :1]; +} +export fn fn2515() void { + dest_end = 3; + _ = src_ptr155[1..dest_end :1]; +} +export fn fn2516() void { + dest_end = 1; + _ = src_ptr155[1..dest_end :1]; +} +comptime { + _ = src_ptr155[1..][0..2 :1]; +} +comptime { + _ = src_ptr155[1..][0..3 :1]; +} +comptime { + _ = src_ptr155[1..][0..1 :1]; +} +export fn fn2517() void { + dest_len = 3; + _ = src_ptr155[1..][0..dest_len :1]; +} +export fn fn2518() void { + dest_len = 1; + _ = src_ptr155[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr155[3.. :1]; +} +comptime { + _ = src_ptr155[3..2 :1]; +} +comptime { + _ = src_ptr155[3..3 :1]; +} +comptime { + _ = src_ptr155[3..1 :1]; +} +export fn fn2519() void { + dest_end = 3; + _ = src_ptr155[3..dest_end :1]; +} +export fn fn2520() void { + dest_end = 1; + _ = src_ptr155[3..dest_end :1]; +} +comptime { + _ = src_ptr155[3..][0..2 :1]; +} +comptime { + _ = src_ptr155[3..][0..3 :1]; +} +comptime { + _ = src_ptr155[3..][0..1 :1]; +} +export fn fn2521() void { + dest_len = 3; + _ = src_ptr155[3..][0..dest_len :1]; +} +export fn fn2522() void { + dest_len = 1; + _ = src_ptr155[3..][0..dest_len :1]; +} +const src_mem114: [2]u8 = .{ 1, 1 }; +var src_ptr156: [*]const u8 = @ptrCast(&src_mem114); +export fn fn2523() void { + _ = src_ptr156[3..2]; +} +export fn fn2524() void { + _ = src_ptr156[3..1]; +} +export fn fn2525() void { + _ = src_ptr156[3..2 :1]; +} +export fn fn2526() void { + _ = src_ptr156[3..1 :1]; +} +const src_mem115: [2]u8 = .{ 1, 0 }; +var src_ptr157: [*:0]const u8 = @ptrCast(&src_mem115); +export fn fn2527() void { + _ = src_ptr157[3..2]; +} +export fn fn2528() void { + _ = src_ptr157[3..1]; +} +export fn fn2529() void { + _ = src_ptr157[3..2 :1]; +} +export fn fn2530() void { + _ = src_ptr157[3..1 :1]; +} +const src_mem116: [3]u8 = .{ 1, 1, 1 }; +var src_ptr158: [*]const u8 = @ptrCast(&src_mem116); +export fn fn2531() void { + _ = src_ptr158[3..2]; +} +export fn fn2532() void { + _ = src_ptr158[3..1]; +} +export fn fn2533() void { + _ = src_ptr158[3..2 :1]; +} +export fn fn2534() void { + _ = src_ptr158[3..1 :1]; +} +const src_mem117: [3]u8 = .{ 1, 1, 0 }; +var src_ptr159: [*:0]const u8 = @ptrCast(&src_mem117); +export fn fn2535() void { + _ = src_ptr159[3..2]; +} +export fn fn2536() void { + _ = src_ptr159[3..1]; +} +export fn fn2537() void { + _ = src_ptr159[3..2 :1]; +} +export fn fn2538() void { + _ = src_ptr159[3..1 :1]; +} +const src_mem118: [1]u8 = .{1}; +var src_ptr160: [*]const u8 = @ptrCast(&src_mem118); +export fn fn2539() void { + _ = src_ptr160[3..2]; +} +export fn fn2540() void { + _ = src_ptr160[3..1]; +} +export fn fn2541() void { + _ = src_ptr160[3..2 :1]; +} +export fn fn2542() void { + _ = src_ptr160[3..1 :1]; +} +const src_mem119: [1]u8 = .{0}; +var src_ptr161: [*:0]const u8 = @ptrCast(&src_mem119); +export fn fn2543() void { + _ = src_ptr161[3..2]; +} +export fn fn2544() void { + _ = src_ptr161[3..1]; +} +export fn fn2545() void { + _ = src_ptr161[3..2 :1]; +} +export fn fn2546() void { + _ = src_ptr161[3..1 :1]; +} +const src_ptr162: [*c]const u8 = nullptr; +comptime { + _ = src_ptr162[0..]; +} +comptime { + _ = src_ptr162[0..2]; +} +comptime { + _ = src_ptr162[0..3]; +} +comptime { + _ = src_ptr162[0..1]; +} +export fn fn2547() void { + dest_end = 3; + _ = src_ptr162[0..dest_end]; +} +export fn fn2548() void { + dest_end = 1; + _ = src_ptr162[0..dest_end]; +} +comptime { + _ = src_ptr162[0..][0..2]; +} +comptime { + _ = src_ptr162[0..][0..3]; +} +comptime { + _ = src_ptr162[0..][0..1]; +} +export fn fn2549() void { + dest_len = 3; + _ = src_ptr162[0..][0..dest_len]; +} +export fn fn2550() void { + dest_len = 1; + _ = src_ptr162[0..][0..dest_len]; +} +comptime { + _ = src_ptr162[1..]; +} +comptime { + _ = src_ptr162[1..2]; +} +comptime { + _ = src_ptr162[1..3]; +} +comptime { + _ = src_ptr162[1..1]; +} +export fn fn2551() void { + dest_end = 3; + _ = src_ptr162[1..dest_end]; +} +export fn fn2552() void { + dest_end = 1; + _ = src_ptr162[1..dest_end]; +} +comptime { + _ = src_ptr162[1..][0..2]; +} +comptime { + _ = src_ptr162[1..][0..3]; +} +comptime { + _ = src_ptr162[1..][0..1]; +} +export fn fn2553() void { + dest_len = 3; + _ = src_ptr162[1..][0..dest_len]; +} +export fn fn2554() void { + dest_len = 1; + _ = src_ptr162[1..][0..dest_len]; +} +comptime { + _ = src_ptr162[3..]; +} +comptime { + _ = src_ptr162[3..2]; +} +comptime { + _ = src_ptr162[3..3]; +} +comptime { + _ = src_ptr162[3..1]; +} +export fn fn2555() void { + dest_end = 3; + _ = src_ptr162[3..dest_end]; +} +export fn fn2556() void { + dest_end = 1; + _ = src_ptr162[3..dest_end]; +} +comptime { + _ = src_ptr162[3..][0..2]; +} +comptime { + _ = src_ptr162[3..][0..3]; +} +comptime { + _ = src_ptr162[3..][0..1]; +} +export fn fn2557() void { + dest_len = 3; + _ = src_ptr162[3..][0..dest_len]; +} +export fn fn2558() void { + dest_len = 1; + _ = src_ptr162[3..][0..dest_len]; +} +comptime { + _ = src_ptr162[0.. :1]; +} +comptime { + _ = src_ptr162[0..2 :1]; +} +comptime { + _ = src_ptr162[0..3 :1]; +} +comptime { + _ = src_ptr162[0..1 :1]; +} +export fn fn2559() void { + dest_end = 3; + _ = src_ptr162[0..dest_end :1]; +} +export fn fn2560() void { + dest_end = 1; + _ = src_ptr162[0..dest_end :1]; +} +comptime { + _ = src_ptr162[0..][0..2 :1]; +} +comptime { + _ = src_ptr162[0..][0..3 :1]; +} +comptime { + _ = src_ptr162[0..][0..1 :1]; +} +export fn fn2561() void { + dest_len = 3; + _ = src_ptr162[0..][0..dest_len :1]; +} +export fn fn2562() void { + dest_len = 1; + _ = src_ptr162[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr162[1.. :1]; +} +comptime { + _ = src_ptr162[1..2 :1]; +} +comptime { + _ = src_ptr162[1..3 :1]; +} +comptime { + _ = src_ptr162[1..1 :1]; +} +export fn fn2563() void { + dest_end = 3; + _ = src_ptr162[1..dest_end :1]; +} +export fn fn2564() void { + dest_end = 1; + _ = src_ptr162[1..dest_end :1]; +} +comptime { + _ = src_ptr162[1..][0..2 :1]; +} +comptime { + _ = src_ptr162[1..][0..3 :1]; +} +comptime { + _ = src_ptr162[1..][0..1 :1]; +} +export fn fn2565() void { + dest_len = 3; + _ = src_ptr162[1..][0..dest_len :1]; +} +export fn fn2566() void { + dest_len = 1; + _ = src_ptr162[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr162[3.. :1]; +} +comptime { + _ = src_ptr162[3..2 :1]; +} +comptime { + _ = src_ptr162[3..3 :1]; +} +comptime { + _ = src_ptr162[3..1 :1]; +} +export fn fn2567() void { + dest_end = 3; + _ = src_ptr162[3..dest_end :1]; +} +export fn fn2568() void { + dest_end = 1; + _ = src_ptr162[3..dest_end :1]; +} +comptime { + _ = src_ptr162[3..][0..2 :1]; +} +comptime { + _ = src_ptr162[3..][0..3 :1]; +} +comptime { + _ = src_ptr162[3..][0..1 :1]; +} +export fn fn2569() void { + dest_len = 3; + _ = src_ptr162[3..][0..dest_len :1]; +} +export fn fn2570() void { + dest_len = 1; + _ = src_ptr162[3..][0..dest_len :1]; +} +const src_ptr163: [*c]const u8 = nullptr; +comptime { + _ = src_ptr163[0..]; +} +comptime { + _ = src_ptr163[0..2]; +} +comptime { + _ = src_ptr163[0..3]; +} +comptime { + _ = src_ptr163[0..1]; +} +export fn fn2571() void { + dest_end = 3; + _ = src_ptr163[0..dest_end]; +} +export fn fn2572() void { + dest_end = 1; + _ = src_ptr163[0..dest_end]; +} +comptime { + _ = src_ptr163[0..][0..2]; +} +comptime { + _ = src_ptr163[0..][0..3]; +} +comptime { + _ = src_ptr163[0..][0..1]; +} +export fn fn2573() void { + dest_len = 3; + _ = src_ptr163[0..][0..dest_len]; +} +export fn fn2574() void { + dest_len = 1; + _ = src_ptr163[0..][0..dest_len]; +} +comptime { + _ = src_ptr163[1..]; +} +comptime { + _ = src_ptr163[1..2]; +} +comptime { + _ = src_ptr163[1..3]; +} +comptime { + _ = src_ptr163[1..1]; +} +export fn fn2575() void { + dest_end = 3; + _ = src_ptr163[1..dest_end]; +} +export fn fn2576() void { + dest_end = 1; + _ = src_ptr163[1..dest_end]; +} +comptime { + _ = src_ptr163[1..][0..2]; +} +comptime { + _ = src_ptr163[1..][0..3]; +} +comptime { + _ = src_ptr163[1..][0..1]; +} +export fn fn2577() void { + dest_len = 3; + _ = src_ptr163[1..][0..dest_len]; +} +export fn fn2578() void { + dest_len = 1; + _ = src_ptr163[1..][0..dest_len]; +} +comptime { + _ = src_ptr163[3..]; +} +comptime { + _ = src_ptr163[3..2]; +} +comptime { + _ = src_ptr163[3..3]; +} +comptime { + _ = src_ptr163[3..1]; +} +export fn fn2579() void { + dest_end = 3; + _ = src_ptr163[3..dest_end]; +} +export fn fn2580() void { + dest_end = 1; + _ = src_ptr163[3..dest_end]; +} +comptime { + _ = src_ptr163[3..][0..2]; +} +comptime { + _ = src_ptr163[3..][0..3]; +} +comptime { + _ = src_ptr163[3..][0..1]; +} +export fn fn2581() void { + dest_len = 3; + _ = src_ptr163[3..][0..dest_len]; +} +export fn fn2582() void { + dest_len = 1; + _ = src_ptr163[3..][0..dest_len]; +} +comptime { + _ = src_ptr163[0.. :1]; +} +comptime { + _ = src_ptr163[0..2 :1]; +} +comptime { + _ = src_ptr163[0..3 :1]; +} +comptime { + _ = src_ptr163[0..1 :1]; +} +export fn fn2583() void { + dest_end = 3; + _ = src_ptr163[0..dest_end :1]; +} +export fn fn2584() void { + dest_end = 1; + _ = src_ptr163[0..dest_end :1]; +} +comptime { + _ = src_ptr163[0..][0..2 :1]; +} +comptime { + _ = src_ptr163[0..][0..3 :1]; +} +comptime { + _ = src_ptr163[0..][0..1 :1]; +} +export fn fn2585() void { + dest_len = 3; + _ = src_ptr163[0..][0..dest_len :1]; +} +export fn fn2586() void { + dest_len = 1; + _ = src_ptr163[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr163[1.. :1]; +} +comptime { + _ = src_ptr163[1..2 :1]; +} +comptime { + _ = src_ptr163[1..3 :1]; +} +comptime { + _ = src_ptr163[1..1 :1]; +} +export fn fn2587() void { + dest_end = 3; + _ = src_ptr163[1..dest_end :1]; +} +export fn fn2588() void { + dest_end = 1; + _ = src_ptr163[1..dest_end :1]; +} +comptime { + _ = src_ptr163[1..][0..2 :1]; +} +comptime { + _ = src_ptr163[1..][0..3 :1]; +} +comptime { + _ = src_ptr163[1..][0..1 :1]; +} +export fn fn2589() void { + dest_len = 3; + _ = src_ptr163[1..][0..dest_len :1]; +} +export fn fn2590() void { + dest_len = 1; + _ = src_ptr163[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr163[3.. :1]; +} +comptime { + _ = src_ptr163[3..2 :1]; +} +comptime { + _ = src_ptr163[3..3 :1]; +} +comptime { + _ = src_ptr163[3..1 :1]; +} +export fn fn2591() void { + dest_end = 3; + _ = src_ptr163[3..dest_end :1]; +} +export fn fn2592() void { + dest_end = 1; + _ = src_ptr163[3..dest_end :1]; +} +comptime { + _ = src_ptr163[3..][0..2 :1]; +} +comptime { + _ = src_ptr163[3..][0..3 :1]; +} +comptime { + _ = src_ptr163[3..][0..1 :1]; +} +export fn fn2593() void { + dest_len = 3; + _ = src_ptr163[3..][0..dest_len :1]; +} +export fn fn2594() void { + dest_len = 1; + _ = src_ptr163[3..][0..dest_len :1]; +} +const src_ptr164: [*c]const u8 = nullptr; +comptime { + _ = src_ptr164[0..]; +} +comptime { + _ = src_ptr164[0..2]; +} +comptime { + _ = src_ptr164[0..3]; +} +comptime { + _ = src_ptr164[0..1]; +} +export fn fn2595() void { + dest_end = 3; + _ = src_ptr164[0..dest_end]; +} +export fn fn2596() void { + dest_end = 1; + _ = src_ptr164[0..dest_end]; +} +comptime { + _ = src_ptr164[0..][0..2]; +} +comptime { + _ = src_ptr164[0..][0..3]; +} +comptime { + _ = src_ptr164[0..][0..1]; +} +export fn fn2597() void { + dest_len = 3; + _ = src_ptr164[0..][0..dest_len]; +} +export fn fn2598() void { + dest_len = 1; + _ = src_ptr164[0..][0..dest_len]; +} +comptime { + _ = src_ptr164[1..]; +} +comptime { + _ = src_ptr164[1..2]; +} +comptime { + _ = src_ptr164[1..3]; +} +comptime { + _ = src_ptr164[1..1]; +} +export fn fn2599() void { + dest_end = 3; + _ = src_ptr164[1..dest_end]; +} +export fn fn2600() void { + dest_end = 1; + _ = src_ptr164[1..dest_end]; +} +comptime { + _ = src_ptr164[1..][0..2]; +} +comptime { + _ = src_ptr164[1..][0..3]; +} +comptime { + _ = src_ptr164[1..][0..1]; +} +export fn fn2601() void { + dest_len = 3; + _ = src_ptr164[1..][0..dest_len]; +} +export fn fn2602() void { + dest_len = 1; + _ = src_ptr164[1..][0..dest_len]; +} +comptime { + _ = src_ptr164[3..]; +} +comptime { + _ = src_ptr164[3..2]; +} +comptime { + _ = src_ptr164[3..3]; +} +comptime { + _ = src_ptr164[3..1]; +} +export fn fn2603() void { + dest_end = 3; + _ = src_ptr164[3..dest_end]; +} +export fn fn2604() void { + dest_end = 1; + _ = src_ptr164[3..dest_end]; +} +comptime { + _ = src_ptr164[3..][0..2]; +} +comptime { + _ = src_ptr164[3..][0..3]; +} +comptime { + _ = src_ptr164[3..][0..1]; +} +export fn fn2605() void { + dest_len = 3; + _ = src_ptr164[3..][0..dest_len]; +} +export fn fn2606() void { + dest_len = 1; + _ = src_ptr164[3..][0..dest_len]; +} +comptime { + _ = src_ptr164[0.. :1]; +} +comptime { + _ = src_ptr164[0..2 :1]; +} +comptime { + _ = src_ptr164[0..3 :1]; +} +comptime { + _ = src_ptr164[0..1 :1]; +} +export fn fn2607() void { + dest_end = 3; + _ = src_ptr164[0..dest_end :1]; +} +export fn fn2608() void { + dest_end = 1; + _ = src_ptr164[0..dest_end :1]; +} +comptime { + _ = src_ptr164[0..][0..2 :1]; +} +comptime { + _ = src_ptr164[0..][0..3 :1]; +} +comptime { + _ = src_ptr164[0..][0..1 :1]; +} +export fn fn2609() void { + dest_len = 3; + _ = src_ptr164[0..][0..dest_len :1]; +} +export fn fn2610() void { + dest_len = 1; + _ = src_ptr164[0..][0..dest_len :1]; +} +comptime { + _ = src_ptr164[1.. :1]; +} +comptime { + _ = src_ptr164[1..2 :1]; +} +comptime { + _ = src_ptr164[1..3 :1]; +} +comptime { + _ = src_ptr164[1..1 :1]; +} +export fn fn2611() void { + dest_end = 3; + _ = src_ptr164[1..dest_end :1]; +} +export fn fn2612() void { + dest_end = 1; + _ = src_ptr164[1..dest_end :1]; +} +comptime { + _ = src_ptr164[1..][0..2 :1]; +} +comptime { + _ = src_ptr164[1..][0..3 :1]; +} +comptime { + _ = src_ptr164[1..][0..1 :1]; +} +export fn fn2613() void { + dest_len = 3; + _ = src_ptr164[1..][0..dest_len :1]; +} +export fn fn2614() void { + dest_len = 1; + _ = src_ptr164[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr164[3.. :1]; +} +comptime { + _ = src_ptr164[3..2 :1]; +} +comptime { + _ = src_ptr164[3..3 :1]; +} +comptime { + _ = src_ptr164[3..1 :1]; +} +export fn fn2615() void { + dest_end = 3; + _ = src_ptr164[3..dest_end :1]; +} +export fn fn2616() void { + dest_end = 1; + _ = src_ptr164[3..dest_end :1]; +} +comptime { + _ = src_ptr164[3..][0..2 :1]; +} +comptime { + _ = src_ptr164[3..][0..3 :1]; +} +comptime { + _ = src_ptr164[3..][0..1 :1]; +} +export fn fn2617() void { + dest_len = 3; + _ = src_ptr164[3..][0..dest_len :1]; +} +export fn fn2618() void { + dest_len = 1; + _ = src_ptr164[3..][0..dest_len :1]; +} +var src_ptr165: [*c]const u8 = null; +export fn fn2619() void { + _ = src_ptr165[3..2]; +} +export fn fn2620() void { + _ = src_ptr165[3..1]; +} +export fn fn2621() void { + _ = src_ptr165[3..2 :1]; +} +export fn fn2622() void { + _ = src_ptr165[3..1 :1]; +} +var src_ptr166: [*c]const u8 = null; +export fn fn2623() void { + _ = src_ptr166[3..2]; +} +export fn fn2624() void { + _ = src_ptr166[3..1]; +} +export fn fn2625() void { + _ = src_ptr166[3..2 :1]; +} +export fn fn2626() void { + _ = src_ptr166[3..1 :1]; +} +var src_ptr167: [*c]const u8 = null; +export fn fn2627() void { + _ = src_ptr167[3..2]; +} +export fn fn2628() void { + _ = src_ptr167[3..1]; +} +export fn fn2629() void { + _ = src_ptr167[3..2 :1]; +} +export fn fn2630() void { + _ = src_ptr167[3..1 :1]; +} +const src_mem120: [2]u8 = .{ 1, 1 }; +const src_ptr168: [*c]const u8 = @ptrCast(&src_mem120); +comptime { + _ = src_ptr168[0..3]; +} +comptime { + _ = src_ptr168[0..][0..3]; +} +comptime { + _ = src_ptr168[1..3]; +} +comptime { + _ = src_ptr168[1..][0..2]; +} +comptime { + _ = src_ptr168[1..][0..3]; +} +comptime { + _ = src_ptr168[3..]; +} +comptime { + _ = src_ptr168[3..2]; +} +comptime { + _ = src_ptr168[3..3]; +} +comptime { + _ = src_ptr168[3..1]; +} +export fn fn2631() void { + dest_end = 3; + _ = src_ptr168[3..dest_end]; +} +export fn fn2632() void { + dest_end = 1; + _ = src_ptr168[3..dest_end]; +} +comptime { + _ = src_ptr168[3..][0..2]; +} +comptime { + _ = src_ptr168[3..][0..3]; +} +comptime { + _ = src_ptr168[3..][0..1]; +} +export fn fn2633() void { + dest_len = 3; + _ = src_ptr168[3..][0..dest_len]; +} +export fn fn2634() void { + dest_len = 1; + _ = src_ptr168[3..][0..dest_len]; +} +comptime { + _ = src_ptr168[0..2 :1]; +} +comptime { + _ = src_ptr168[0..3 :1]; +} +comptime { + _ = src_ptr168[0..][0..2 :1]; +} +comptime { + _ = src_ptr168[0..][0..3 :1]; +} +comptime { + _ = src_ptr168[1..2 :1]; +} +comptime { + _ = src_ptr168[1..3 :1]; +} +comptime { + _ = src_ptr168[1..][0..2 :1]; +} +comptime { + _ = src_ptr168[1..][0..3 :1]; +} +comptime { + _ = src_ptr168[1..][0..1 :1]; +} +comptime { + _ = src_ptr168[3.. :1]; +} +comptime { + _ = src_ptr168[3..2 :1]; +} +comptime { + _ = src_ptr168[3..3 :1]; +} +comptime { + _ = src_ptr168[3..1 :1]; +} +export fn fn2635() void { + dest_end = 3; + _ = src_ptr168[3..dest_end :1]; +} +export fn fn2636() void { + dest_end = 1; + _ = src_ptr168[3..dest_end :1]; +} +comptime { + _ = src_ptr168[3..][0..2 :1]; +} +comptime { + _ = src_ptr168[3..][0..3 :1]; +} +comptime { + _ = src_ptr168[3..][0..1 :1]; +} +export fn fn2637() void { + dest_len = 3; + _ = src_ptr168[3..][0..dest_len :1]; +} +export fn fn2638() void { + dest_len = 1; + _ = src_ptr168[3..][0..dest_len :1]; +} +const src_mem121: [3]u8 = .{ 1, 1, 1 }; +const src_ptr169: [*c]const u8 = @ptrCast(&src_mem121); +comptime { + _ = src_ptr169[1..][0..3]; +} +comptime { + _ = src_ptr169[3..2]; +} +comptime { + _ = src_ptr169[3..1]; +} +comptime { + _ = src_ptr169[3..][0..2]; +} +comptime { + _ = src_ptr169[3..][0..3]; +} +comptime { + _ = src_ptr169[3..][0..1]; +} +comptime { + _ = src_ptr169[0..3 :1]; +} +comptime { + _ = src_ptr169[0..][0..3 :1]; +} +comptime { + _ = src_ptr169[1..3 :1]; +} +comptime { + _ = src_ptr169[1..][0..2 :1]; +} +comptime { + _ = src_ptr169[1..][0..3 :1]; +} +comptime { + _ = src_ptr169[3.. :1]; +} +comptime { + _ = src_ptr169[3..2 :1]; +} +comptime { + _ = src_ptr169[3..3 :1]; +} +comptime { + _ = src_ptr169[3..1 :1]; +} +export fn fn2639() void { + dest_end = 3; + _ = src_ptr169[3..dest_end :1]; +} +export fn fn2640() void { + dest_end = 1; + _ = src_ptr169[3..dest_end :1]; +} +comptime { + _ = src_ptr169[3..][0..2 :1]; +} +comptime { + _ = src_ptr169[3..][0..3 :1]; +} +comptime { + _ = src_ptr169[3..][0..1 :1]; +} +export fn fn2641() void { + dest_len = 3; + _ = src_ptr169[3..][0..dest_len :1]; +} +export fn fn2642() void { + dest_len = 1; + _ = src_ptr169[3..][0..dest_len :1]; +} +const src_mem122: [1]u8 = .{1}; +const src_ptr170: [*c]const u8 = @ptrCast(&src_mem122); +comptime { + _ = src_ptr170[0..2]; +} +comptime { + _ = src_ptr170[0..3]; +} +comptime { + _ = src_ptr170[0..][0..2]; +} +comptime { + _ = src_ptr170[0..][0..3]; +} +comptime { + _ = src_ptr170[1..2]; +} +comptime { + _ = src_ptr170[1..3]; +} +comptime { + _ = src_ptr170[1..][0..2]; +} +comptime { + _ = src_ptr170[1..][0..3]; +} +comptime { + _ = src_ptr170[1..][0..1]; +} +comptime { + _ = src_ptr170[3..]; +} +comptime { + _ = src_ptr170[3..2]; +} +comptime { + _ = src_ptr170[3..3]; +} +comptime { + _ = src_ptr170[3..1]; +} +export fn fn2643() void { + dest_end = 3; + _ = src_ptr170[3..dest_end]; +} +export fn fn2644() void { + dest_end = 1; + _ = src_ptr170[3..dest_end]; +} +comptime { + _ = src_ptr170[3..][0..2]; +} +comptime { + _ = src_ptr170[3..][0..3]; +} +comptime { + _ = src_ptr170[3..][0..1]; +} +export fn fn2645() void { + dest_len = 3; + _ = src_ptr170[3..][0..dest_len]; +} +export fn fn2646() void { + dest_len = 1; + _ = src_ptr170[3..][0..dest_len]; +} +comptime { + _ = src_ptr170[0..2 :1]; +} +comptime { + _ = src_ptr170[0..3 :1]; +} +comptime { + _ = src_ptr170[0..1 :1]; +} +comptime { + _ = src_ptr170[0..][0..2 :1]; +} +comptime { + _ = src_ptr170[0..][0..3 :1]; +} +comptime { + _ = src_ptr170[0..][0..1 :1]; +} +comptime { + _ = src_ptr170[1.. :1]; +} +comptime { + _ = src_ptr170[1..2 :1]; +} +comptime { + _ = src_ptr170[1..3 :1]; +} +comptime { + _ = src_ptr170[1..1 :1]; +} +export fn fn2647() void { + dest_end = 3; + _ = src_ptr170[1..dest_end :1]; +} +export fn fn2648() void { + dest_end = 1; + _ = src_ptr170[1..dest_end :1]; +} +comptime { + _ = src_ptr170[1..][0..2 :1]; +} +comptime { + _ = src_ptr170[1..][0..3 :1]; +} +comptime { + _ = src_ptr170[1..][0..1 :1]; +} +export fn fn2649() void { + dest_len = 3; + _ = src_ptr170[1..][0..dest_len :1]; +} +export fn fn2650() void { + dest_len = 1; + _ = src_ptr170[1..][0..dest_len :1]; +} +comptime { + _ = src_ptr170[3.. :1]; +} +comptime { + _ = src_ptr170[3..2 :1]; +} +comptime { + _ = src_ptr170[3..3 :1]; +} +comptime { + _ = src_ptr170[3..1 :1]; +} +export fn fn2651() void { + dest_end = 3; + _ = src_ptr170[3..dest_end :1]; +} +export fn fn2652() void { + dest_end = 1; + _ = src_ptr170[3..dest_end :1]; +} +comptime { + _ = src_ptr170[3..][0..2 :1]; +} +comptime { + _ = src_ptr170[3..][0..3 :1]; +} +comptime { + _ = src_ptr170[3..][0..1 :1]; +} +export fn fn2653() void { + dest_len = 3; + _ = src_ptr170[3..][0..dest_len :1]; +} +export fn fn2654() void { + dest_len = 1; + _ = src_ptr170[3..][0..dest_len :1]; +} +const src_mem123: [2]u8 = .{ 1, 1 }; +var src_ptr171: [*c]const u8 = @ptrCast(&src_mem123); +export fn fn2655() void { + _ = src_ptr171[3..2]; +} +export fn fn2656() void { + _ = src_ptr171[3..1]; +} +export fn fn2657() void { + _ = src_ptr171[3..2 :1]; +} +export fn fn2658() void { + _ = src_ptr171[3..1 :1]; +} +const src_mem124: [3]u8 = .{ 1, 1, 1 }; +var src_ptr172: [*c]const u8 = @ptrCast(&src_mem124); +export fn fn2659() void { + _ = src_ptr172[3..2]; +} +export fn fn2660() void { + _ = src_ptr172[3..1]; +} +export fn fn2661() void { + _ = src_ptr172[3..2 :1]; +} +export fn fn2662() void { + _ = src_ptr172[3..1 :1]; +} +const src_mem125: [1]u8 = .{1}; +var src_ptr173: [*c]const u8 = @ptrCast(&src_mem125); +export fn fn2663() void { + _ = src_ptr173[3..2]; +} +export fn fn2664() void { + _ = src_ptr173[3..1]; +} +export fn fn2665() void { + _ = src_ptr173[3..2 :1]; +} +export fn fn2666() void { + _ = src_ptr173[3..1 :1]; +} +// error +// +// :5253:22: error: slice end out of bounds: end 3, length 2 +// :5256:27: error: slice end out of bounds: end 3, length 2 +// :5259:22: error: slice end out of bounds: end 3, length 2 +// :5262:27: error: slice end out of bounds: end 3, length 2 +// :5265:27: error: slice end out of bounds: end 4, length 2 +// :5268:19: error: slice start out of bounds: start 3, length 2 +// :5271:19: error: bounds out of order: start 3, end 2 +// :5274:22: error: slice end out of bounds: end 3, length 2 +// :5277:19: error: bounds out of order: start 3, end 1 +// :5288:27: error: slice end out of bounds: end 5, length 2 +// :5291:27: error: slice end out of bounds: end 6, length 2 +// :5294:27: error: slice end out of bounds: end 4, length 2 +// :5305:24: error: sentinel index always out of bounds +// :5308:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :5311:22: error: slice end out of bounds: end 3(+1), length 2 +// :5314:25: error: mismatched sentinel: expected 1, found 0 +// :5317:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :5320:27: error: slice end out of bounds: end 3(+1), length 2 +// :5323:30: error: mismatched sentinel: expected 1, found 0 +// :5326:24: error: sentinel index always out of bounds +// :5329:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :5332:22: error: slice end out of bounds: end 3(+1), length 2 +// :5335:25: error: mismatched sentinel: expected 1, found 0 +// :5338:27: error: slice end out of bounds: end 3(+1), length 2 +// :5341:27: error: slice end out of bounds: end 4(+1), length 2 +// :5344:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :5347:24: error: sentinel index always out of bounds +// :5350:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :5353:22: error: slice end out of bounds: end 3(+1), length 2 +// :5356:19: error: bounds out of order: start 3, end 1 +// :5367:27: error: slice end out of bounds: end 5(+1), length 2 +// :5370:27: error: slice end out of bounds: end 6(+1), length 2 +// :5373:27: error: slice end out of bounds: end 4(+1), length 2 +// :5386:22: error: slice end out of bounds: end 3, length 2 +// :5389:27: error: slice end out of bounds: end 3, length 2 +// :5392:22: error: slice end out of bounds: end 3, length 2 +// :5395:27: error: slice end out of bounds: end 3, length 2 +// :5398:27: error: slice end out of bounds: end 4, length 2 +// :5401:19: error: slice start out of bounds: start 3, length 1 +// :5404:19: error: bounds out of order: start 3, end 2 +// :5407:22: error: slice end out of bounds: end 3, length 2 +// :5410:19: error: bounds out of order: start 3, end 1 +// :5421:27: error: slice end out of bounds: end 5, length 2 +// :5424:27: error: slice end out of bounds: end 6, length 2 +// :5427:27: error: slice end out of bounds: end 4, length 2 +// :5438:24: error: mismatched sentinel: expected 1, found 0 +// :5441:22: error: slice end out of bounds: end 2, length 1 +// :5444:22: error: slice end out of bounds: end 3, length 1 +// :5447:25: error: mismatched sentinel: expected 1, found 0 +// :5450:27: error: slice end out of bounds: end 2, length 1 +// :5453:27: error: slice end out of bounds: end 3, length 1 +// :5456:30: error: mismatched sentinel: expected 1, found 0 +// :5459:24: error: mismatched sentinel: expected 1, found 0 +// :5462:22: error: slice end out of bounds: end 2, length 1 +// :5465:22: error: slice end out of bounds: end 3, length 1 +// :5468:25: error: mismatched sentinel: expected 1, found 0 +// :5471:27: error: slice end out of bounds: end 3, length 1 +// :5474:27: error: slice end out of bounds: end 4, length 1 +// :5477:27: error: slice end out of bounds: end 2, length 1 +// :5480:19: error: slice start out of bounds: start 3, length 1 +// :5483:22: error: slice end out of bounds: end 2, length 1 +// :5486:22: error: slice end out of bounds: end 3, length 1 +// :5489:19: error: bounds out of order: start 3, end 1 +// :5500:27: error: slice end out of bounds: end 5, length 1 +// :5503:27: error: slice end out of bounds: end 6, length 1 +// :5506:27: error: slice end out of bounds: end 4, length 1 +// :5519:27: error: slice end out of bounds: end 4, length 3 +// :5522:19: error: bounds out of order: start 3, end 2 +// :5525:19: error: bounds out of order: start 3, end 1 +// :5528:27: error: slice end out of bounds: end 5, length 3 +// :5531:27: error: slice end out of bounds: end 6, length 3 +// :5534:27: error: slice end out of bounds: end 4, length 3 +// :5537:24: error: sentinel index always out of bounds +// :5540:25: error: mismatched sentinel: expected 1, found 0 +// :5543:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :5546:25: error: mismatched sentinel: expected 1, found 0 +// :5549:30: error: mismatched sentinel: expected 1, found 0 +// :5552:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :5555:30: error: mismatched sentinel: expected 1, found 0 +// :5558:24: error: sentinel index always out of bounds +// :5561:25: error: mismatched sentinel: expected 1, found 0 +// :5564:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :5567:25: error: mismatched sentinel: expected 1, found 0 +// :5570:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :5573:27: error: slice end out of bounds: end 4(+1), length 3 +// :5576:30: error: mismatched sentinel: expected 1, found 0 +// :5579:24: error: sentinel index always out of bounds +// :5582:19: error: bounds out of order: start 3, end 2 +// :5585:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :5588:19: error: bounds out of order: start 3, end 1 +// :5599:27: error: slice end out of bounds: end 5(+1), length 3 +// :5602:27: error: slice end out of bounds: end 6(+1), length 3 +// :5605:27: error: slice end out of bounds: end 4(+1), length 3 +// :5618:27: error: slice end out of bounds: end 4, length 3 +// :5621:19: error: slice start out of bounds: start 3, length 2 +// :5624:19: error: bounds out of order: start 3, end 2 +// :5627:19: error: bounds out of order: start 3, end 1 +// :5630:27: error: slice end out of bounds: end 5, length 3 +// :5633:27: error: slice end out of bounds: end 6, length 3 +// :5636:27: error: slice end out of bounds: end 4, length 3 +// :5639:24: error: mismatched sentinel: expected 1, found 0 +// :5642:25: error: mismatched sentinel: expected 1, found 0 +// :5645:22: error: slice end out of bounds: end 3, length 2 +// :5648:25: error: mismatched sentinel: expected 1, found 0 +// :5651:30: error: mismatched sentinel: expected 1, found 0 +// :5654:27: error: slice end out of bounds: end 3, length 2 +// :5657:30: error: mismatched sentinel: expected 1, found 0 +// :5660:24: error: mismatched sentinel: expected 1, found 0 +// :5663:25: error: mismatched sentinel: expected 1, found 0 +// :5666:22: error: slice end out of bounds: end 3, length 2 +// :5669:25: error: mismatched sentinel: expected 1, found 0 +// :5672:27: error: slice end out of bounds: end 3, length 2 +// :5675:27: error: slice end out of bounds: end 4, length 2 +// :5678:30: error: mismatched sentinel: expected 1, found 0 +// :5681:19: error: slice start out of bounds: start 3, length 2 +// :5684:19: error: bounds out of order: start 3, end 2 +// :5687:22: error: slice end out of bounds: end 3, length 2 +// :5690:19: error: bounds out of order: start 3, end 1 +// :5701:27: error: slice end out of bounds: end 5, length 2 +// :5704:27: error: slice end out of bounds: end 6, length 2 +// :5707:27: error: slice end out of bounds: end 4, length 2 +// :5720:22: error: slice end out of bounds: end 2, length 1 +// :5723:22: error: slice end out of bounds: end 3, length 1 +// :5726:27: error: slice end out of bounds: end 2, length 1 +// :5729:27: error: slice end out of bounds: end 3, length 1 +// :5732:22: error: slice end out of bounds: end 2, length 1 +// :5735:22: error: slice end out of bounds: end 3, length 1 +// :5738:27: error: slice end out of bounds: end 3, length 1 +// :5741:27: error: slice end out of bounds: end 4, length 1 +// :5744:27: error: slice end out of bounds: end 2, length 1 +// :5747:19: error: slice start out of bounds: start 3, length 1 +// :5750:22: error: slice end out of bounds: end 2, length 1 +// :5753:22: error: slice end out of bounds: end 3, length 1 +// :5756:19: error: bounds out of order: start 3, end 1 +// :5767:27: error: slice end out of bounds: end 5, length 1 +// :5770:27: error: slice end out of bounds: end 6, length 1 +// :5773:27: error: slice end out of bounds: end 4, length 1 +// :5784:24: error: sentinel index always out of bounds +// :5787:22: error: slice end out of bounds: end 2(+1), length 1 +// :5790:22: error: slice end out of bounds: end 3(+1), length 1 +// :5793:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :5796:27: error: slice end out of bounds: end 2(+1), length 1 +// :5799:27: error: slice end out of bounds: end 3(+1), length 1 +// :5802:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :5805:24: error: sentinel index always out of bounds +// :5808:22: error: slice end out of bounds: end 2(+1), length 1 +// :5811:22: error: slice end out of bounds: end 3(+1), length 1 +// :5814:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :5825:27: error: slice end out of bounds: end 3(+1), length 1 +// :5828:27: error: slice end out of bounds: end 4(+1), length 1 +// :5831:27: error: slice end out of bounds: end 2(+1), length 1 +// :5842:24: error: sentinel index always out of bounds +// :5845:22: error: slice end out of bounds: end 2(+1), length 1 +// :5848:22: error: slice end out of bounds: end 3(+1), length 1 +// :5851:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :5862:27: error: slice end out of bounds: end 5(+1), length 1 +// :5865:27: error: slice end out of bounds: end 6(+1), length 1 +// :5868:27: error: slice end out of bounds: end 4(+1), length 1 +// :5881:22: error: slice end out of bounds: end 2, length 1 +// :5884:22: error: slice end out of bounds: end 3, length 1 +// :5887:27: error: slice end out of bounds: end 2, length 1 +// :5890:27: error: slice end out of bounds: end 3, length 1 +// :5893:19: error: slice start out of bounds: start 1, length 0 +// :5896:22: error: slice end out of bounds: end 2, length 1 +// :5899:22: error: slice end out of bounds: end 3, length 1 +// :5902:27: error: slice end out of bounds: end 3, length 1 +// :5905:27: error: slice end out of bounds: end 4, length 1 +// :5908:27: error: slice end out of bounds: end 2, length 1 +// :5911:19: error: slice start out of bounds: start 3, length 0 +// :5914:22: error: slice end out of bounds: end 2, length 1 +// :5917:22: error: slice end out of bounds: end 3, length 1 +// :5920:19: error: bounds out of order: start 3, end 1 +// :5931:27: error: slice end out of bounds: end 5, length 1 +// :5934:27: error: slice end out of bounds: end 6, length 1 +// :5937:27: error: slice end out of bounds: end 4, length 1 +// :5948:24: error: mismatched sentinel: expected 1, found 0 +// :5951:22: error: slice end out of bounds: end 2, length 0 +// :5954:22: error: slice end out of bounds: end 3, length 0 +// :5957:22: error: slice end out of bounds: end 1, length 0 +// :5960:27: error: slice end out of bounds: end 2, length 0 +// :5963:27: error: slice end out of bounds: end 3, length 0 +// :5966:27: error: slice end out of bounds: end 1, length 0 +// :5969:19: error: slice start out of bounds: start 1, length 0 +// :5972:22: error: slice end out of bounds: end 2, length 0 +// :5975:22: error: slice end out of bounds: end 3, length 0 +// :5978:22: error: slice end out of bounds: end 1, length 0 +// :5989:27: error: slice end out of bounds: end 3, length 0 +// :5992:27: error: slice end out of bounds: end 4, length 0 +// :5995:27: error: slice end out of bounds: end 2, length 0 +// :6006:19: error: slice start out of bounds: start 3, length 0 +// :6009:22: error: slice end out of bounds: end 2, length 0 +// :6012:22: error: slice end out of bounds: end 3, length 0 +// :6015:22: error: slice end out of bounds: end 1, length 0 +// :6026:27: error: slice end out of bounds: end 5, length 0 +// :6029:27: error: slice end out of bounds: end 6, length 0 +// :6032:27: error: slice end out of bounds: end 4, length 0 +// :6762:22: error: slice end out of bounds: end 3, length 2 +// :6765:27: error: slice end out of bounds: end 3, length 2 +// :6768:22: error: slice end out of bounds: end 3, length 2 +// :6771:27: error: slice end out of bounds: end 3, length 2 +// :6774:27: error: slice end out of bounds: end 4, length 2 +// :6777:19: error: slice start out of bounds: start 3, length 2 +// :6780:19: error: bounds out of order: start 3, end 2 +// :6783:22: error: slice end out of bounds: end 3, length 2 +// :6786:19: error: bounds out of order: start 3, end 1 +// :6797:27: error: slice end out of bounds: end 5, length 2 +// :6800:27: error: slice end out of bounds: end 6, length 2 +// :6803:27: error: slice end out of bounds: end 4, length 2 +// :6814:24: error: sentinel index always out of bounds +// :6817:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6820:22: error: slice end out of bounds: end 3(+1), length 2 +// :6823:25: error: mismatched sentinel: expected 1, found 0 +// :6826:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6829:27: error: slice end out of bounds: end 3(+1), length 2 +// :6832:30: error: mismatched sentinel: expected 1, found 0 +// :6835:24: error: sentinel index always out of bounds +// :6838:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6841:22: error: slice end out of bounds: end 3(+1), length 2 +// :6844:25: error: mismatched sentinel: expected 1, found 0 +// :6847:27: error: slice end out of bounds: end 3(+1), length 2 +// :6850:27: error: slice end out of bounds: end 4(+1), length 2 +// :6853:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6856:24: error: sentinel index always out of bounds +// :6859:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6862:22: error: slice end out of bounds: end 3(+1), length 2 +// :6865:19: error: bounds out of order: start 3, end 1 +// :6876:27: error: slice end out of bounds: end 5(+1), length 2 +// :6879:27: error: slice end out of bounds: end 6(+1), length 2 +// :6882:27: error: slice end out of bounds: end 4(+1), length 2 +// :6895:22: error: slice end out of bounds: end 3, length 2 +// :6898:27: error: slice end out of bounds: end 3, length 2 +// :6901:22: error: slice end out of bounds: end 3, length 2 +// :6904:27: error: slice end out of bounds: end 3, length 2 +// :6907:27: error: slice end out of bounds: end 4, length 2 +// :6910:19: error: slice start out of bounds: start 3, length 1 +// :6913:19: error: bounds out of order: start 3, end 2 +// :6916:22: error: slice end out of bounds: end 3, length 2 +// :6919:19: error: bounds out of order: start 3, end 1 +// :6930:27: error: slice end out of bounds: end 5, length 2 +// :6933:27: error: slice end out of bounds: end 6, length 2 +// :6936:27: error: slice end out of bounds: end 4, length 2 +// :6947:24: error: mismatched sentinel: expected 1, found 0 +// :6950:22: error: slice end out of bounds: end 2, length 1 +// :6953:22: error: slice end out of bounds: end 3, length 1 +// :6956:25: error: mismatched sentinel: expected 1, found 0 +// :6959:27: error: slice end out of bounds: end 2, length 1 +// :6962:27: error: slice end out of bounds: end 3, length 1 +// :6965:30: error: mismatched sentinel: expected 1, found 0 +// :6968:24: error: mismatched sentinel: expected 1, found 0 +// :6971:22: error: slice end out of bounds: end 2, length 1 +// :6974:22: error: slice end out of bounds: end 3, length 1 +// :6977:25: error: mismatched sentinel: expected 1, found 0 +// :6980:27: error: slice end out of bounds: end 3, length 1 +// :6983:27: error: slice end out of bounds: end 4, length 1 +// :6986:27: error: slice end out of bounds: end 2, length 1 +// :6989:19: error: slice start out of bounds: start 3, length 1 +// :6992:22: error: slice end out of bounds: end 2, length 1 +// :6995:22: error: slice end out of bounds: end 3, length 1 +// :6998:19: error: bounds out of order: start 3, end 1 +// :7009:27: error: slice end out of bounds: end 5, length 1 +// :7012:27: error: slice end out of bounds: end 6, length 1 +// :7015:27: error: slice end out of bounds: end 4, length 1 +// :7028:27: error: slice end out of bounds: end 4, length 3 +// :7031:19: error: bounds out of order: start 3, end 2 +// :7034:19: error: bounds out of order: start 3, end 1 +// :7037:27: error: slice end out of bounds: end 5, length 3 +// :7040:27: error: slice end out of bounds: end 6, length 3 +// :7043:27: error: slice end out of bounds: end 4, length 3 +// :7046:24: error: sentinel index always out of bounds +// :7049:25: error: mismatched sentinel: expected 1, found 0 +// :7052:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :7055:25: error: mismatched sentinel: expected 1, found 0 +// :7058:30: error: mismatched sentinel: expected 1, found 0 +// :7061:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :7064:30: error: mismatched sentinel: expected 1, found 0 +// :7067:24: error: sentinel index always out of bounds +// :7070:25: error: mismatched sentinel: expected 1, found 0 +// :7073:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :7076:25: error: mismatched sentinel: expected 1, found 0 +// :7079:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :7082:27: error: slice end out of bounds: end 4(+1), length 3 +// :7085:30: error: mismatched sentinel: expected 1, found 0 +// :7088:24: error: sentinel index always out of bounds +// :7091:19: error: bounds out of order: start 3, end 2 +// :7094:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :7097:19: error: bounds out of order: start 3, end 1 +// :7108:27: error: slice end out of bounds: end 5(+1), length 3 +// :7111:27: error: slice end out of bounds: end 6(+1), length 3 +// :7114:27: error: slice end out of bounds: end 4(+1), length 3 +// :7127:27: error: slice end out of bounds: end 4, length 3 +// :7130:19: error: slice start out of bounds: start 3, length 2 +// :7133:19: error: bounds out of order: start 3, end 2 +// :7136:19: error: bounds out of order: start 3, end 1 +// :7139:27: error: slice end out of bounds: end 5, length 3 +// :7142:27: error: slice end out of bounds: end 6, length 3 +// :7145:27: error: slice end out of bounds: end 4, length 3 +// :7148:24: error: mismatched sentinel: expected 1, found 0 +// :7151:25: error: mismatched sentinel: expected 1, found 0 +// :7154:22: error: slice end out of bounds: end 3, length 2 +// :7157:25: error: mismatched sentinel: expected 1, found 0 +// :7160:30: error: mismatched sentinel: expected 1, found 0 +// :7163:27: error: slice end out of bounds: end 3, length 2 +// :7166:30: error: mismatched sentinel: expected 1, found 0 +// :7169:24: error: mismatched sentinel: expected 1, found 0 +// :7172:25: error: mismatched sentinel: expected 1, found 0 +// :7175:22: error: slice end out of bounds: end 3, length 2 +// :7178:25: error: mismatched sentinel: expected 1, found 0 +// :7181:27: error: slice end out of bounds: end 3, length 2 +// :7184:27: error: slice end out of bounds: end 4, length 2 +// :7187:30: error: mismatched sentinel: expected 1, found 0 +// :7190:19: error: slice start out of bounds: start 3, length 2 +// :7193:19: error: bounds out of order: start 3, end 2 +// :7196:22: error: slice end out of bounds: end 3, length 2 +// :7199:19: error: bounds out of order: start 3, end 1 +// :7210:27: error: slice end out of bounds: end 5, length 2 +// :7213:27: error: slice end out of bounds: end 6, length 2 +// :7216:27: error: slice end out of bounds: end 4, length 2 +// :7229:22: error: slice end out of bounds: end 2, length 1 +// :7232:22: error: slice end out of bounds: end 3, length 1 +// :7235:27: error: slice end out of bounds: end 2, length 1 +// :7238:27: error: slice end out of bounds: end 3, length 1 +// :7241:22: error: slice end out of bounds: end 2, length 1 +// :7244:22: error: slice end out of bounds: end 3, length 1 +// :7247:27: error: slice end out of bounds: end 3, length 1 +// :7250:27: error: slice end out of bounds: end 4, length 1 +// :7253:27: error: slice end out of bounds: end 2, length 1 +// :7256:19: error: slice start out of bounds: start 3, length 1 +// :7259:22: error: slice end out of bounds: end 2, length 1 +// :7262:22: error: slice end out of bounds: end 3, length 1 +// :7265:19: error: bounds out of order: start 3, end 1 +// :7276:27: error: slice end out of bounds: end 5, length 1 +// :7279:27: error: slice end out of bounds: end 6, length 1 +// :7282:27: error: slice end out of bounds: end 4, length 1 +// :7293:24: error: sentinel index always out of bounds +// :7296:22: error: slice end out of bounds: end 2(+1), length 1 +// :7299:22: error: slice end out of bounds: end 3(+1), length 1 +// :7302:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :7305:27: error: slice end out of bounds: end 2(+1), length 1 +// :7308:27: error: slice end out of bounds: end 3(+1), length 1 +// :7311:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :7314:24: error: sentinel index always out of bounds +// :7317:22: error: slice end out of bounds: end 2(+1), length 1 +// :7320:22: error: slice end out of bounds: end 3(+1), length 1 +// :7323:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :7334:27: error: slice end out of bounds: end 3(+1), length 1 +// :7337:27: error: slice end out of bounds: end 4(+1), length 1 +// :7340:27: error: slice end out of bounds: end 2(+1), length 1 +// :7351:24: error: sentinel index always out of bounds +// :7354:22: error: slice end out of bounds: end 2(+1), length 1 +// :7357:22: error: slice end out of bounds: end 3(+1), length 1 +// :7360:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :7371:27: error: slice end out of bounds: end 5(+1), length 1 +// :7374:27: error: slice end out of bounds: end 6(+1), length 1 +// :7377:27: error: slice end out of bounds: end 4(+1), length 1 +// :7390:22: error: slice end out of bounds: end 2, length 1 +// :7393:22: error: slice end out of bounds: end 3, length 1 +// :7396:27: error: slice end out of bounds: end 2, length 1 +// :7399:27: error: slice end out of bounds: end 3, length 1 +// :7402:19: error: slice start out of bounds: start 1, length 0 +// :7405:22: error: slice end out of bounds: end 2, length 1 +// :7408:22: error: slice end out of bounds: end 3, length 1 +// :7411:27: error: slice end out of bounds: end 3, length 1 +// :7414:27: error: slice end out of bounds: end 4, length 1 +// :7417:27: error: slice end out of bounds: end 2, length 1 +// :7420:19: error: slice start out of bounds: start 3, length 0 +// :7423:22: error: slice end out of bounds: end 2, length 1 +// :7426:22: error: slice end out of bounds: end 3, length 1 +// :7429:19: error: bounds out of order: start 3, end 1 +// :7440:27: error: slice end out of bounds: end 5, length 1 +// :7443:27: error: slice end out of bounds: end 6, length 1 +// :7446:27: error: slice end out of bounds: end 4, length 1 +// :7457:24: error: mismatched sentinel: expected 1, found 0 +// :7460:22: error: slice end out of bounds: end 2, length 0 +// :7463:22: error: slice end out of bounds: end 3, length 0 +// :7466:22: error: slice end out of bounds: end 1, length 0 +// :7469:27: error: slice end out of bounds: end 2, length 0 +// :7472:27: error: slice end out of bounds: end 3, length 0 +// :7475:27: error: slice end out of bounds: end 1, length 0 +// :7478:19: error: slice start out of bounds: start 1, length 0 +// :7481:22: error: slice end out of bounds: end 2, length 0 +// :7484:22: error: slice end out of bounds: end 3, length 0 +// :7487:22: error: slice end out of bounds: end 1, length 0 +// :7498:27: error: slice end out of bounds: end 3, length 0 +// :7501:27: error: slice end out of bounds: end 4, length 0 +// :7504:27: error: slice end out of bounds: end 2, length 0 +// :7515:19: error: slice start out of bounds: start 3, length 0 +// :7518:22: error: slice end out of bounds: end 2, length 0 +// :7521:22: error: slice end out of bounds: end 3, length 0 +// :7524:22: error: slice end out of bounds: end 1, length 0 +// :7535:27: error: slice end out of bounds: end 5, length 0 +// :7538:27: error: slice end out of bounds: end 6, length 0 +// :7541:27: error: slice end out of bounds: end 4, length 0 +// :7665:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7668:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7671:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7674:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7677:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :7680:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7683:20: error: bounds out of order: start 3, end 2 +// :7686:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7689:20: error: bounds out of order: start 3, end 1 +// :7700:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :7703:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :7706:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :7717:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7720:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7723:26: error: mismatched sentinel: expected 1, found 0 +// :7726:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7729:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7732:31: error: mismatched sentinel: expected 1, found 0 +// :7735:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7738:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7741:26: error: mismatched sentinel: expected 1, found 0 +// :7744:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7747:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :7750:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7753:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7756:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7759:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7762:20: error: bounds out of order: start 3, end 1 +// :7773:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :7776:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :7779:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :7792:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7795:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7798:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7801:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7804:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :7807:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7810:20: error: bounds out of order: start 3, end 2 +// :7813:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :7816:20: error: bounds out of order: start 3, end 1 +// :7827:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :7830:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :7833:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :7844:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7847:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7850:26: error: mismatched sentinel: expected 1, found 0 +// :7853:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7856:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7859:31: error: mismatched sentinel: expected 1, found 0 +// :7862:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7865:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7868:26: error: mismatched sentinel: expected 1, found 0 +// :7871:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7874:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :7877:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7880:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7883:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :7886:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :7889:20: error: bounds out of order: start 3, end 1 +// :7900:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :7903:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :7906:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :7919:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :7922:20: error: bounds out of order: start 3, end 2 +// :7925:20: error: bounds out of order: start 3, end 1 +// :7928:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :7931:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :7934:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :7937:26: error: mismatched sentinel: expected 1, found 0 +// :7940:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :7943:26: error: mismatched sentinel: expected 1, found 0 +// :7946:31: error: mismatched sentinel: expected 1, found 0 +// :7949:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :7952:31: error: mismatched sentinel: expected 1, found 0 +// :7955:26: error: mismatched sentinel: expected 1, found 0 +// :7958:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :7961:26: error: mismatched sentinel: expected 1, found 0 +// :7964:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :7967:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :7970:31: error: mismatched sentinel: expected 1, found 0 +// :7973:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :7976:20: error: bounds out of order: start 3, end 2 +// :7979:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :7982:20: error: bounds out of order: start 3, end 1 +// :7993:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :7996:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :7999:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :8012:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :8015:20: error: bounds out of order: start 3, end 2 +// :8018:20: error: bounds out of order: start 3, end 1 +// :8021:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :8024:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :8027:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :8030:26: error: mismatched sentinel: expected 1, found 0 +// :8033:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :8036:26: error: mismatched sentinel: expected 1, found 0 +// :8039:31: error: mismatched sentinel: expected 1, found 0 +// :8042:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :8045:31: error: mismatched sentinel: expected 1, found 0 +// :8048:26: error: mismatched sentinel: expected 1, found 0 +// :8051:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :8054:26: error: mismatched sentinel: expected 1, found 0 +// :8057:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :8060:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :8063:31: error: mismatched sentinel: expected 1, found 0 +// :8066:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8069:20: error: bounds out of order: start 3, end 2 +// :8072:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :8075:20: error: bounds out of order: start 3, end 1 +// :8086:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :8089:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :8092:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :8105:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8108:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8111:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8114:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8117:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8120:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8123:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8126:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :8129:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8132:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8135:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8138:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8141:20: error: bounds out of order: start 3, end 1 +// :8152:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :8155:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :8158:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :8169:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8172:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8175:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8178:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8181:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8184:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8187:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8190:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8193:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8196:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8207:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8210:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :8213:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8224:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8227:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8230:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8233:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8244:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :8247:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :8250:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :8263:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8266:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8269:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8272:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8275:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8278:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8281:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8284:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :8287:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8290:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8293:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :8296:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :8299:20: error: bounds out of order: start 3, end 1 +// :8310:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :8313:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :8316:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :8327:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8330:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8333:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8336:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8339:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8342:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8345:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8348:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8351:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8354:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8365:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8368:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :8371:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8382:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8385:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :8388:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :8391:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :8402:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :8405:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :8408:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :8504:9: error: slice of null pointer +// :8507:9: error: slice of null pointer +// :8510:9: error: slice of null pointer +// :8513:9: error: slice of null pointer +// :8524:19: error: slice of null pointer +// :8527:19: error: slice of null pointer +// :8530:19: error: slice of null pointer +// :8541:9: error: slice of null pointer +// :8544:9: error: slice of null pointer +// :8547:9: error: slice of null pointer +// :8550:9: error: slice of null pointer +// :8561:19: error: slice of null pointer +// :8564:19: error: slice of null pointer +// :8567:19: error: slice of null pointer +// :8578:9: error: slice of null pointer +// :8581:20: error: bounds out of order: start 3, end 2 +// :8584:9: error: slice of null pointer +// :8587:20: error: bounds out of order: start 3, end 1 +// :8598:19: error: slice of null pointer +// :8601:19: error: slice of null pointer +// :8604:19: error: slice of null pointer +// :8615:9: error: slice of null pointer +// :8618:9: error: slice of null pointer +// :8621:9: error: slice of null pointer +// :8624:9: error: slice of null pointer +// :8635:19: error: slice of null pointer +// :8638:19: error: slice of null pointer +// :8641:19: error: slice of null pointer +// :8652:9: error: slice of null pointer +// :8655:9: error: slice of null pointer +// :8658:9: error: slice of null pointer +// :8661:9: error: slice of null pointer +// :8672:19: error: slice of null pointer +// :8675:19: error: slice of null pointer +// :8678:19: error: slice of null pointer +// :8689:9: error: slice of null pointer +// :8692:20: error: bounds out of order: start 3, end 2 +// :8695:9: error: slice of null pointer +// :8698:20: error: bounds out of order: start 3, end 1 +// :8709:19: error: slice of null pointer +// :8712:19: error: slice of null pointer +// :8715:19: error: slice of null pointer +// :8727:9: error: slice of null pointer +// :8730:9: error: slice of null pointer +// :8733:9: error: slice of null pointer +// :8736:9: error: slice of null pointer +// :8747:19: error: slice of null pointer +// :8750:19: error: slice of null pointer +// :8753:19: error: slice of null pointer +// :8764:9: error: slice of null pointer +// :8767:9: error: slice of null pointer +// :8770:9: error: slice of null pointer +// :8773:9: error: slice of null pointer +// :8784:19: error: slice of null pointer +// :8787:19: error: slice of null pointer +// :8790:19: error: slice of null pointer +// :8801:9: error: slice of null pointer +// :8804:20: error: bounds out of order: start 3, end 2 +// :8807:9: error: slice of null pointer +// :8810:20: error: bounds out of order: start 3, end 1 +// :8821:19: error: slice of null pointer +// :8824:19: error: slice of null pointer +// :8827:19: error: slice of null pointer +// :8838:9: error: slice of null pointer +// :8841:9: error: slice of null pointer +// :8844:9: error: slice of null pointer +// :8847:9: error: slice of null pointer +// :8858:19: error: slice of null pointer +// :8861:19: error: slice of null pointer +// :8864:19: error: slice of null pointer +// :8875:9: error: slice of null pointer +// :8878:9: error: slice of null pointer +// :8881:9: error: slice of null pointer +// :8884:9: error: slice of null pointer +// :8895:19: error: slice of null pointer +// :8898:19: error: slice of null pointer +// :8901:19: error: slice of null pointer +// :8912:9: error: slice of null pointer +// :8915:20: error: bounds out of order: start 3, end 2 +// :8918:9: error: slice of null pointer +// :8921:20: error: bounds out of order: start 3, end 1 +// :8932:19: error: slice of null pointer +// :8935:19: error: slice of null pointer +// :8938:19: error: slice of null pointer +// :8950:9: error: slice of null pointer +// :8953:9: error: slice of null pointer +// :8956:9: error: slice of null pointer +// :8959:9: error: slice of null pointer +// :8970:19: error: slice of null pointer +// :8973:19: error: slice of null pointer +// :8976:19: error: slice of null pointer +// :8987:9: error: slice of null pointer +// :8990:9: error: slice of null pointer +// :8993:9: error: slice of null pointer +// :8996:9: error: slice of null pointer +// :9007:19: error: slice of null pointer +// :9010:19: error: slice of null pointer +// :9013:19: error: slice of null pointer +// :9024:9: error: slice of null pointer +// :9027:20: error: bounds out of order: start 3, end 2 +// :9030:9: error: slice of null pointer +// :9033:20: error: bounds out of order: start 3, end 1 +// :9044:19: error: slice of null pointer +// :9047:19: error: slice of null pointer +// :9050:19: error: slice of null pointer +// :9061:9: error: slice of null pointer +// :9064:9: error: slice of null pointer +// :9067:9: error: slice of null pointer +// :9070:9: error: slice of null pointer +// :9081:19: error: slice of null pointer +// :9084:19: error: slice of null pointer +// :9087:19: error: slice of null pointer +// :9098:9: error: slice of null pointer +// :9101:9: error: slice of null pointer +// :9104:9: error: slice of null pointer +// :9107:9: error: slice of null pointer +// :9118:19: error: slice of null pointer +// :9121:19: error: slice of null pointer +// :9124:19: error: slice of null pointer +// :9135:9: error: slice of null pointer +// :9138:20: error: bounds out of order: start 3, end 2 +// :9141:9: error: slice of null pointer +// :9144:20: error: bounds out of order: start 3, end 1 +// :9155:19: error: slice of null pointer +// :9158:19: error: slice of null pointer +// :9161:19: error: slice of null pointer +// :9213:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :9216:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :9219:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :9222:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :9225:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :9228:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9231:20: error: bounds out of order: start 3, end 2 +// :9234:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :9237:20: error: bounds out of order: start 3, end 1 +// :9248:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :9251:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :9254:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :9265:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :9268:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :9271:26: error: mismatched sentinel: expected 1, found 0 +// :9274:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :9277:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :9280:31: error: mismatched sentinel: expected 1, found 0 +// :9283:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :9286:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :9289:26: error: mismatched sentinel: expected 1, found 0 +// :9292:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :9295:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :9298:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :9301:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9304:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :9307:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :9310:20: error: bounds out of order: start 3, end 1 +// :9321:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :9324:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :9327:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :9340:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :9343:20: error: bounds out of order: start 3, end 2 +// :9346:20: error: bounds out of order: start 3, end 1 +// :9349:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :9352:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :9355:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :9358:26: error: mismatched sentinel: expected 1, found 0 +// :9361:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :9364:26: error: mismatched sentinel: expected 1, found 0 +// :9367:31: error: mismatched sentinel: expected 1, found 0 +// :9370:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :9373:31: error: mismatched sentinel: expected 1, found 0 +// :9376:26: error: mismatched sentinel: expected 1, found 0 +// :9379:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :9382:26: error: mismatched sentinel: expected 1, found 0 +// :9385:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :9388:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :9391:31: error: mismatched sentinel: expected 1, found 0 +// :9394:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :9397:20: error: bounds out of order: start 3, end 2 +// :9400:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :9403:20: error: bounds out of order: start 3, end 1 +// :9414:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :9417:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :9420:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :9433:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :9436:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :9439:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :9442:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :9445:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :9448:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :9451:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :9454:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :9457:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :9460:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9463:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :9466:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :9469:20: error: bounds out of order: start 3, end 1 +// :9480:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :9483:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :9486:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :9497:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :9500:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :9503:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :9506:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :9509:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :9512:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :9515:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :9518:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :9521:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :9524:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :9535:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :9538:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :9541:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :9552:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9555:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :9558:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :9561:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :9572:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :9575:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :9578:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :9633:23: error: slice end out of bounds: end 3, length 2 +// :9636:28: error: slice end out of bounds: end 3, length 2 +// :9639:23: error: slice end out of bounds: end 3, length 2 +// :9642:28: error: slice end out of bounds: end 3, length 2 +// :9645:28: error: slice end out of bounds: end 4, length 2 +// :9648:20: error: slice start out of bounds: start 3, length 2 +// :9651:20: error: bounds out of order: start 3, end 2 +// :9654:23: error: slice end out of bounds: end 3, length 2 +// :9657:20: error: bounds out of order: start 3, end 1 +// :9668:28: error: slice end out of bounds: end 5, length 2 +// :9671:28: error: slice end out of bounds: end 6, length 2 +// :9674:28: error: slice end out of bounds: end 4, length 2 +// :9685:25: error: sentinel index always out of bounds +// :9688:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :9691:23: error: slice end out of bounds: end 3(+1), length 2 +// :9694:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :9697:28: error: slice end out of bounds: end 3(+1), length 2 +// :9700:25: error: sentinel index always out of bounds +// :9703:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :9706:23: error: slice end out of bounds: end 3(+1), length 2 +// :9709:28: error: slice end out of bounds: end 3(+1), length 2 +// :9712:28: error: slice end out of bounds: end 4(+1), length 2 +// :9715:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :9718:25: error: sentinel index always out of bounds +// :9721:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :9724:23: error: slice end out of bounds: end 3(+1), length 2 +// :9727:20: error: bounds out of order: start 3, end 1 +// :9738:28: error: slice end out of bounds: end 5(+1), length 2 +// :9741:28: error: slice end out of bounds: end 6(+1), length 2 +// :9744:28: error: slice end out of bounds: end 4(+1), length 2 +// :9757:23: error: slice end out of bounds: end 3, length 2 +// :9760:28: error: slice end out of bounds: end 3, length 2 +// :9763:23: error: slice end out of bounds: end 3, length 2 +// :9766:28: error: slice end out of bounds: end 3, length 2 +// :9769:28: error: slice end out of bounds: end 4, length 2 +// :9772:20: error: slice start out of bounds: start 3, length 1 +// :9775:20: error: bounds out of order: start 3, end 2 +// :9778:23: error: slice end out of bounds: end 3, length 2 +// :9781:20: error: bounds out of order: start 3, end 1 +// :9792:28: error: slice end out of bounds: end 5, length 2 +// :9795:28: error: slice end out of bounds: end 6, length 2 +// :9798:28: error: slice end out of bounds: end 4, length 2 +// :9809:25: error: mismatched sentinel: expected 1, found 0 +// :9812:23: error: slice end out of bounds: end 2, length 1 +// :9815:23: error: slice end out of bounds: end 3, length 1 +// :9818:26: error: mismatched sentinel: expected 1, found 0 +// :9821:28: error: slice end out of bounds: end 2, length 1 +// :9824:28: error: slice end out of bounds: end 3, length 1 +// :9827:31: error: mismatched sentinel: expected 1, found 0 +// :9830:25: error: mismatched sentinel: expected 1, found 0 +// :9833:23: error: slice end out of bounds: end 2, length 1 +// :9836:23: error: slice end out of bounds: end 3, length 1 +// :9839:26: error: mismatched sentinel: expected 1, found 0 +// :9842:28: error: slice end out of bounds: end 3, length 1 +// :9845:28: error: slice end out of bounds: end 4, length 1 +// :9848:28: error: slice end out of bounds: end 2, length 1 +// :9851:20: error: slice start out of bounds: start 3, length 1 +// :9854:23: error: slice end out of bounds: end 2, length 1 +// :9857:23: error: slice end out of bounds: end 3, length 1 +// :9860:20: error: bounds out of order: start 3, end 1 +// :9871:28: error: slice end out of bounds: end 5, length 1 +// :9874:28: error: slice end out of bounds: end 6, length 1 +// :9877:28: error: slice end out of bounds: end 4, length 1 +// :9890:28: error: slice end out of bounds: end 4, length 3 +// :9893:20: error: bounds out of order: start 3, end 2 +// :9896:20: error: bounds out of order: start 3, end 1 +// :9899:28: error: slice end out of bounds: end 5, length 3 +// :9902:28: error: slice end out of bounds: end 6, length 3 +// :9905:28: error: slice end out of bounds: end 4, length 3 +// :9908:25: error: sentinel index always out of bounds +// :9911:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :9914:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :9917:25: error: sentinel index always out of bounds +// :9920:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :9923:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :9926:28: error: slice end out of bounds: end 4(+1), length 3 +// :9929:25: error: sentinel index always out of bounds +// :9932:20: error: bounds out of order: start 3, end 2 +// :9935:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :9938:20: error: bounds out of order: start 3, end 1 +// :9949:28: error: slice end out of bounds: end 5(+1), length 3 +// :9952:28: error: slice end out of bounds: end 6(+1), length 3 +// :9955:28: error: slice end out of bounds: end 4(+1), length 3 +// :9968:28: error: slice end out of bounds: end 4, length 3 +// :9971:20: error: slice start out of bounds: start 3, length 2 +// :9974:20: error: bounds out of order: start 3, end 2 +// :9977:20: error: bounds out of order: start 3, end 1 +// :9980:28: error: slice end out of bounds: end 5, length 3 +// :9983:28: error: slice end out of bounds: end 6, length 3 +// :9986:28: error: slice end out of bounds: end 4, length 3 +// :9989:25: error: mismatched sentinel: expected 1, found 0 +// :9992:26: error: mismatched sentinel: expected 1, found 0 +// :9995:23: error: slice end out of bounds: end 3, length 2 +// :9998:31: error: mismatched sentinel: expected 1, found 0 +// :10001:28: error: slice end out of bounds: end 3, length 2 +// :10004:25: error: mismatched sentinel: expected 1, found 0 +// :10007:26: error: mismatched sentinel: expected 1, found 0 +// :10010:23: error: slice end out of bounds: end 3, length 2 +// :10013:28: error: slice end out of bounds: end 3, length 2 +// :10016:28: error: slice end out of bounds: end 4, length 2 +// :10019:31: error: mismatched sentinel: expected 1, found 0 +// :10022:20: error: slice start out of bounds: start 3, length 2 +// :10025:20: error: bounds out of order: start 3, end 2 +// :10028:23: error: slice end out of bounds: end 3, length 2 +// :10031:20: error: bounds out of order: start 3, end 1 +// :10042:28: error: slice end out of bounds: end 5, length 2 +// :10045:28: error: slice end out of bounds: end 6, length 2 +// :10048:28: error: slice end out of bounds: end 4, length 2 +// :10061:23: error: slice end out of bounds: end 2, length 1 +// :10064:23: error: slice end out of bounds: end 3, length 1 +// :10067:28: error: slice end out of bounds: end 2, length 1 +// :10070:28: error: slice end out of bounds: end 3, length 1 +// :10073:23: error: slice end out of bounds: end 2, length 1 +// :10076:23: error: slice end out of bounds: end 3, length 1 +// :10079:28: error: slice end out of bounds: end 3, length 1 +// :10082:28: error: slice end out of bounds: end 4, length 1 +// :10085:28: error: slice end out of bounds: end 2, length 1 +// :10088:20: error: slice start out of bounds: start 3, length 1 +// :10091:23: error: slice end out of bounds: end 2, length 1 +// :10094:23: error: slice end out of bounds: end 3, length 1 +// :10097:20: error: bounds out of order: start 3, end 1 +// :10108:28: error: slice end out of bounds: end 5, length 1 +// :10111:28: error: slice end out of bounds: end 6, length 1 +// :10114:28: error: slice end out of bounds: end 4, length 1 +// :10125:25: error: sentinel index always out of bounds +// :10128:23: error: slice end out of bounds: end 2(+1), length 1 +// :10131:23: error: slice end out of bounds: end 3(+1), length 1 +// :10134:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10137:28: error: slice end out of bounds: end 2(+1), length 1 +// :10140:28: error: slice end out of bounds: end 3(+1), length 1 +// :10143:28: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10146:25: error: sentinel index always out of bounds +// :10149:23: error: slice end out of bounds: end 2(+1), length 1 +// :10152:23: error: slice end out of bounds: end 3(+1), length 1 +// :10155:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10166:28: error: slice end out of bounds: end 3(+1), length 1 +// :10169:28: error: slice end out of bounds: end 4(+1), length 1 +// :10172:28: error: slice end out of bounds: end 2(+1), length 1 +// :10183:25: error: sentinel index always out of bounds +// :10186:23: error: slice end out of bounds: end 2(+1), length 1 +// :10189:23: error: slice end out of bounds: end 3(+1), length 1 +// :10192:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10203:28: error: slice end out of bounds: end 5(+1), length 1 +// :10206:28: error: slice end out of bounds: end 6(+1), length 1 +// :10209:28: error: slice end out of bounds: end 4(+1), length 1 +// :10222:23: error: slice end out of bounds: end 2, length 1 +// :10225:23: error: slice end out of bounds: end 3, length 1 +// :10228:28: error: slice end out of bounds: end 2, length 1 +// :10231:28: error: slice end out of bounds: end 3, length 1 +// :10234:20: error: slice start out of bounds: start 1, length 0 +// :10237:23: error: slice end out of bounds: end 2, length 1 +// :10240:23: error: slice end out of bounds: end 3, length 1 +// :10243:28: error: slice end out of bounds: end 3, length 1 +// :10246:28: error: slice end out of bounds: end 4, length 1 +// :10249:28: error: slice end out of bounds: end 2, length 1 +// :10252:20: error: slice start out of bounds: start 3, length 0 +// :10255:23: error: slice end out of bounds: end 2, length 1 +// :10258:23: error: slice end out of bounds: end 3, length 1 +// :10261:20: error: bounds out of order: start 3, end 1 +// :10272:28: error: slice end out of bounds: end 5, length 1 +// :10275:28: error: slice end out of bounds: end 6, length 1 +// :10278:28: error: slice end out of bounds: end 4, length 1 +// :10289:25: error: mismatched sentinel: expected 1, found 0 +// :10292:23: error: slice end out of bounds: end 2, length 0 +// :10295:23: error: slice end out of bounds: end 3, length 0 +// :10298:23: error: slice end out of bounds: end 1, length 0 +// :10301:28: error: slice end out of bounds: end 2, length 0 +// :10304:28: error: slice end out of bounds: end 3, length 0 +// :10307:28: error: slice end out of bounds: end 1, length 0 +// :10310:20: error: slice start out of bounds: start 1, length 0 +// :10313:23: error: slice end out of bounds: end 2, length 0 +// :10316:23: error: slice end out of bounds: end 3, length 0 +// :10319:23: error: slice end out of bounds: end 1, length 0 +// :10330:28: error: slice end out of bounds: end 3, length 0 +// :10333:28: error: slice end out of bounds: end 4, length 0 +// :10336:28: error: slice end out of bounds: end 2, length 0 +// :10347:20: error: slice start out of bounds: start 3, length 0 +// :10350:23: error: slice end out of bounds: end 2, length 0 +// :10353:23: error: slice end out of bounds: end 3, length 0 +// :10356:23: error: slice end out of bounds: end 1, length 0 +// :10367:28: error: slice end out of bounds: end 5, length 0 +// :10370:28: error: slice end out of bounds: end 6, length 0 +// :10373:28: error: slice end out of bounds: end 4, length 0 +// :11103:23: error: slice end out of bounds: end 3, length 2 +// :11106:28: error: slice end out of bounds: end 3, length 2 +// :11109:23: error: slice end out of bounds: end 3, length 2 +// :11112:28: error: slice end out of bounds: end 3, length 2 +// :11115:28: error: slice end out of bounds: end 4, length 2 +// :11118:20: error: slice start out of bounds: start 3, length 2 +// :11121:20: error: bounds out of order: start 3, end 2 +// :11124:23: error: slice end out of bounds: end 3, length 2 +// :11127:20: error: bounds out of order: start 3, end 1 +// :11138:28: error: slice end out of bounds: end 5, length 2 +// :11141:28: error: slice end out of bounds: end 6, length 2 +// :11144:28: error: slice end out of bounds: end 4, length 2 +// :11155:25: error: sentinel index always out of bounds +// :11158:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :11161:23: error: slice end out of bounds: end 3(+1), length 2 +// :11164:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :11167:28: error: slice end out of bounds: end 3(+1), length 2 +// :11170:25: error: sentinel index always out of bounds +// :11173:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :11176:23: error: slice end out of bounds: end 3(+1), length 2 +// :11179:28: error: slice end out of bounds: end 3(+1), length 2 +// :11182:28: error: slice end out of bounds: end 4(+1), length 2 +// :11185:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :11188:25: error: sentinel index always out of bounds +// :11191:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :11194:23: error: slice end out of bounds: end 3(+1), length 2 +// :11197:20: error: bounds out of order: start 3, end 1 +// :11208:28: error: slice end out of bounds: end 5(+1), length 2 +// :11211:28: error: slice end out of bounds: end 6(+1), length 2 +// :11214:28: error: slice end out of bounds: end 4(+1), length 2 +// :11227:23: error: slice end out of bounds: end 3, length 2 +// :11230:28: error: slice end out of bounds: end 3, length 2 +// :11233:23: error: slice end out of bounds: end 3, length 2 +// :11236:28: error: slice end out of bounds: end 3, length 2 +// :11239:28: error: slice end out of bounds: end 4, length 2 +// :11242:20: error: slice start out of bounds: start 3, length 1 +// :11245:20: error: bounds out of order: start 3, end 2 +// :11248:23: error: slice end out of bounds: end 3, length 2 +// :11251:20: error: bounds out of order: start 3, end 1 +// :11262:28: error: slice end out of bounds: end 5, length 2 +// :11265:28: error: slice end out of bounds: end 6, length 2 +// :11268:28: error: slice end out of bounds: end 4, length 2 +// :11279:25: error: mismatched sentinel: expected 1, found 0 +// :11282:23: error: slice end out of bounds: end 2, length 1 +// :11285:23: error: slice end out of bounds: end 3, length 1 +// :11288:26: error: mismatched sentinel: expected 1, found 0 +// :11291:28: error: slice end out of bounds: end 2, length 1 +// :11294:28: error: slice end out of bounds: end 3, length 1 +// :11297:31: error: mismatched sentinel: expected 1, found 0 +// :11300:25: error: mismatched sentinel: expected 1, found 0 +// :11303:23: error: slice end out of bounds: end 2, length 1 +// :11306:23: error: slice end out of bounds: end 3, length 1 +// :11309:26: error: mismatched sentinel: expected 1, found 0 +// :11312:28: error: slice end out of bounds: end 3, length 1 +// :11315:28: error: slice end out of bounds: end 4, length 1 +// :11318:28: error: slice end out of bounds: end 2, length 1 +// :11321:20: error: slice start out of bounds: start 3, length 1 +// :11324:23: error: slice end out of bounds: end 2, length 1 +// :11327:23: error: slice end out of bounds: end 3, length 1 +// :11330:20: error: bounds out of order: start 3, end 1 +// :11341:28: error: slice end out of bounds: end 5, length 1 +// :11344:28: error: slice end out of bounds: end 6, length 1 +// :11347:28: error: slice end out of bounds: end 4, length 1 +// :11360:28: error: slice end out of bounds: end 4, length 3 +// :11363:20: error: bounds out of order: start 3, end 2 +// :11366:20: error: bounds out of order: start 3, end 1 +// :11369:28: error: slice end out of bounds: end 5, length 3 +// :11372:28: error: slice end out of bounds: end 6, length 3 +// :11375:28: error: slice end out of bounds: end 4, length 3 +// :11378:25: error: sentinel index always out of bounds +// :11381:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :11384:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :11387:25: error: sentinel index always out of bounds +// :11390:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :11393:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :11396:28: error: slice end out of bounds: end 4(+1), length 3 +// :11399:25: error: sentinel index always out of bounds +// :11402:20: error: bounds out of order: start 3, end 2 +// :11405:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :11408:20: error: bounds out of order: start 3, end 1 +// :11419:28: error: slice end out of bounds: end 5(+1), length 3 +// :11422:28: error: slice end out of bounds: end 6(+1), length 3 +// :11425:28: error: slice end out of bounds: end 4(+1), length 3 +// :11438:28: error: slice end out of bounds: end 4, length 3 +// :11441:20: error: slice start out of bounds: start 3, length 2 +// :11444:20: error: bounds out of order: start 3, end 2 +// :11447:20: error: bounds out of order: start 3, end 1 +// :11450:28: error: slice end out of bounds: end 5, length 3 +// :11453:28: error: slice end out of bounds: end 6, length 3 +// :11456:28: error: slice end out of bounds: end 4, length 3 +// :11459:25: error: mismatched sentinel: expected 1, found 0 +// :11462:26: error: mismatched sentinel: expected 1, found 0 +// :11465:23: error: slice end out of bounds: end 3, length 2 +// :11468:31: error: mismatched sentinel: expected 1, found 0 +// :11471:28: error: slice end out of bounds: end 3, length 2 +// :11474:25: error: mismatched sentinel: expected 1, found 0 +// :11477:26: error: mismatched sentinel: expected 1, found 0 +// :11480:23: error: slice end out of bounds: end 3, length 2 +// :11483:28: error: slice end out of bounds: end 3, length 2 +// :11486:28: error: slice end out of bounds: end 4, length 2 +// :11489:31: error: mismatched sentinel: expected 1, found 0 +// :11492:20: error: slice start out of bounds: start 3, length 2 +// :11495:20: error: bounds out of order: start 3, end 2 +// :11498:23: error: slice end out of bounds: end 3, length 2 +// :11501:20: error: bounds out of order: start 3, end 1 +// :11512:28: error: slice end out of bounds: end 5, length 2 +// :11515:28: error: slice end out of bounds: end 6, length 2 +// :11518:28: error: slice end out of bounds: end 4, length 2 +// :11531:23: error: slice end out of bounds: end 2, length 1 +// :11534:23: error: slice end out of bounds: end 3, length 1 +// :11537:28: error: slice end out of bounds: end 2, length 1 +// :11540:28: error: slice end out of bounds: end 3, length 1 +// :11543:23: error: slice end out of bounds: end 2, length 1 +// :11546:23: error: slice end out of bounds: end 3, length 1 +// :11549:28: error: slice end out of bounds: end 3, length 1 +// :11552:28: error: slice end out of bounds: end 4, length 1 +// :11555:28: error: slice end out of bounds: end 2, length 1 +// :11558:20: error: slice start out of bounds: start 3, length 1 +// :11561:23: error: slice end out of bounds: end 2, length 1 +// :11564:23: error: slice end out of bounds: end 3, length 1 +// :11567:20: error: bounds out of order: start 3, end 1 +// :11578:28: error: slice end out of bounds: end 5, length 1 +// :11581:28: error: slice end out of bounds: end 6, length 1 +// :11584:28: error: slice end out of bounds: end 4, length 1 +// :11595:25: error: sentinel index always out of bounds +// :11598:23: error: slice end out of bounds: end 2(+1), length 1 +// :11601:23: error: slice end out of bounds: end 3(+1), length 1 +// :11604:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :11607:28: error: slice end out of bounds: end 2(+1), length 1 +// :11610:28: error: slice end out of bounds: end 3(+1), length 1 +// :11613:28: error: slice sentinel out of bounds: end 1(+1), length 1 +// :11616:25: error: sentinel index always out of bounds +// :11619:23: error: slice end out of bounds: end 2(+1), length 1 +// :11622:23: error: slice end out of bounds: end 3(+1), length 1 +// :11625:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :11636:28: error: slice end out of bounds: end 3(+1), length 1 +// :11639:28: error: slice end out of bounds: end 4(+1), length 1 +// :11642:28: error: slice end out of bounds: end 2(+1), length 1 +// :11653:25: error: sentinel index always out of bounds +// :11656:23: error: slice end out of bounds: end 2(+1), length 1 +// :11659:23: error: slice end out of bounds: end 3(+1), length 1 +// :11662:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :11673:28: error: slice end out of bounds: end 5(+1), length 1 +// :11676:28: error: slice end out of bounds: end 6(+1), length 1 +// :11679:28: error: slice end out of bounds: end 4(+1), length 1 +// :11692:23: error: slice end out of bounds: end 2, length 1 +// :11695:23: error: slice end out of bounds: end 3, length 1 +// :11698:28: error: slice end out of bounds: end 2, length 1 +// :11701:28: error: slice end out of bounds: end 3, length 1 +// :11704:20: error: slice start out of bounds: start 1, length 0 +// :11707:23: error: slice end out of bounds: end 2, length 1 +// :11710:23: error: slice end out of bounds: end 3, length 1 +// :11713:28: error: slice end out of bounds: end 3, length 1 +// :11716:28: error: slice end out of bounds: end 4, length 1 +// :11719:28: error: slice end out of bounds: end 2, length 1 +// :11722:20: error: slice start out of bounds: start 3, length 0 +// :11725:23: error: slice end out of bounds: end 2, length 1 +// :11728:23: error: slice end out of bounds: end 3, length 1 +// :11731:20: error: bounds out of order: start 3, end 1 +// :11742:28: error: slice end out of bounds: end 5, length 1 +// :11745:28: error: slice end out of bounds: end 6, length 1 +// :11748:28: error: slice end out of bounds: end 4, length 1 +// :11759:25: error: mismatched sentinel: expected 1, found 0 +// :11762:23: error: slice end out of bounds: end 2, length 0 +// :11765:23: error: slice end out of bounds: end 3, length 0 +// :11768:23: error: slice end out of bounds: end 1, length 0 +// :11771:28: error: slice end out of bounds: end 2, length 0 +// :11774:28: error: slice end out of bounds: end 3, length 0 +// :11777:28: error: slice end out of bounds: end 1, length 0 +// :11780:20: error: slice start out of bounds: start 1, length 0 +// :11783:23: error: slice end out of bounds: end 2, length 0 +// :11786:23: error: slice end out of bounds: end 3, length 0 +// :11789:23: error: slice end out of bounds: end 1, length 0 +// :11800:28: error: slice end out of bounds: end 3, length 0 +// :11803:28: error: slice end out of bounds: end 4, length 0 +// :11806:28: error: slice end out of bounds: end 2, length 0 +// :11817:20: error: slice start out of bounds: start 3, length 0 +// :11820:23: error: slice end out of bounds: end 2, length 0 +// :11823:23: error: slice end out of bounds: end 3, length 0 +// :11826:23: error: slice end out of bounds: end 1, length 0 +// :11837:28: error: slice end out of bounds: end 5, length 0 +// :11840:28: error: slice end out of bounds: end 6, length 0 +// :11843:28: error: slice end out of bounds: end 4, length 0 +// :11967:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :11970:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :11973:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :11976:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :11979:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :11982:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :11985:20: error: bounds out of order: start 3, end 2 +// :11988:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :11991:20: error: bounds out of order: start 3, end 1 +// :12002:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :12005:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :12008:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :12019:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12022:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12025:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12028:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12031:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12034:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12037:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12040:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :12043:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12046:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12049:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12052:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12055:20: error: bounds out of order: start 3, end 1 +// :12066:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :12069:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :12072:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :12085:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :12088:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :12091:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :12094:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :12097:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :12100:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12103:20: error: bounds out of order: start 3, end 2 +// :12106:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :12109:20: error: bounds out of order: start 3, end 1 +// :12120:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :12123:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :12126:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :12137:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12140:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12143:26: error: mismatched sentinel: expected 1, found 0 +// :12146:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12149:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12152:31: error: mismatched sentinel: expected 1, found 0 +// :12155:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12158:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12161:26: error: mismatched sentinel: expected 1, found 0 +// :12164:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12167:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :12170:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12173:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12176:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :12179:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :12182:20: error: bounds out of order: start 3, end 1 +// :12193:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :12196:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :12199:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :12212:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :12215:20: error: bounds out of order: start 3, end 2 +// :12218:20: error: bounds out of order: start 3, end 1 +// :12221:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :12224:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :12227:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :12230:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12233:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12236:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12239:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12242:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :12245:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12248:20: error: bounds out of order: start 3, end 2 +// :12251:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12254:20: error: bounds out of order: start 3, end 1 +// :12265:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :12268:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :12271:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :12284:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :12287:20: error: bounds out of order: start 3, end 2 +// :12290:20: error: bounds out of order: start 3, end 1 +// :12293:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :12296:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :12299:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :12302:26: error: mismatched sentinel: expected 1, found 0 +// :12305:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12308:31: error: mismatched sentinel: expected 1, found 0 +// :12311:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12314:26: error: mismatched sentinel: expected 1, found 0 +// :12317:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12320:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12323:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :12326:31: error: mismatched sentinel: expected 1, found 0 +// :12329:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12332:20: error: bounds out of order: start 3, end 2 +// :12335:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :12338:20: error: bounds out of order: start 3, end 1 +// :12349:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :12352:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :12355:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :12368:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12371:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12374:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12377:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12380:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12383:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12386:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12389:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :12392:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12395:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12398:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12401:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12404:20: error: bounds out of order: start 3, end 1 +// :12415:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :12418:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :12421:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :12432:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12435:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12438:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12441:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12444:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12447:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12450:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12453:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12456:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12459:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12470:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12473:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :12476:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12487:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12490:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12493:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12496:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12507:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :12510:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :12513:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :12526:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12529:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12532:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12535:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12538:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12541:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12544:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12547:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :12550:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12553:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12556:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :12559:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :12562:20: error: bounds out of order: start 3, end 1 +// :12573:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :12576:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :12579:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :12590:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12593:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12596:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12599:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12602:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12605:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12608:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12611:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12614:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12617:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12628:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12631:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :12634:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12645:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12648:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :12651:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :12654:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :12665:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :12668:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :12671:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :12767:9: error: slice of null pointer +// :12770:9: error: slice of null pointer +// :12773:9: error: slice of null pointer +// :12776:9: error: slice of null pointer +// :12787:19: error: slice of null pointer +// :12790:19: error: slice of null pointer +// :12793:19: error: slice of null pointer +// :12804:9: error: slice of null pointer +// :12807:9: error: slice of null pointer +// :12810:9: error: slice of null pointer +// :12813:9: error: slice of null pointer +// :12824:19: error: slice of null pointer +// :12827:19: error: slice of null pointer +// :12830:19: error: slice of null pointer +// :12841:9: error: slice of null pointer +// :12844:20: error: bounds out of order: start 3, end 2 +// :12847:9: error: slice of null pointer +// :12850:20: error: bounds out of order: start 3, end 1 +// :12861:19: error: slice of null pointer +// :12864:19: error: slice of null pointer +// :12867:19: error: slice of null pointer +// :12878:9: error: slice of null pointer +// :12881:9: error: slice of null pointer +// :12884:9: error: slice of null pointer +// :12887:9: error: slice of null pointer +// :12898:19: error: slice of null pointer +// :12901:19: error: slice of null pointer +// :12904:19: error: slice of null pointer +// :12915:9: error: slice of null pointer +// :12918:9: error: slice of null pointer +// :12921:9: error: slice of null pointer +// :12924:9: error: slice of null pointer +// :12935:19: error: slice of null pointer +// :12938:19: error: slice of null pointer +// :12941:19: error: slice of null pointer +// :12952:9: error: slice of null pointer +// :12955:20: error: bounds out of order: start 3, end 2 +// :12958:9: error: slice of null pointer +// :12961:20: error: bounds out of order: start 3, end 1 +// :12972:19: error: slice of null pointer +// :12975:19: error: slice of null pointer +// :12978:19: error: slice of null pointer +// :12990:9: error: slice of null pointer +// :12993:9: error: slice of null pointer +// :12996:9: error: slice of null pointer +// :12999:9: error: slice of null pointer +// :13010:19: error: slice of null pointer +// :13013:19: error: slice of null pointer +// :13016:19: error: slice of null pointer +// :13027:9: error: slice of null pointer +// :13030:9: error: slice of null pointer +// :13033:9: error: slice of null pointer +// :13036:9: error: slice of null pointer +// :13047:19: error: slice of null pointer +// :13050:19: error: slice of null pointer +// :13053:19: error: slice of null pointer +// :13064:9: error: slice of null pointer +// :13067:20: error: bounds out of order: start 3, end 2 +// :13070:9: error: slice of null pointer +// :13073:20: error: bounds out of order: start 3, end 1 +// :13084:19: error: slice of null pointer +// :13087:19: error: slice of null pointer +// :13090:19: error: slice of null pointer +// :13101:9: error: slice of null pointer +// :13104:9: error: slice of null pointer +// :13107:9: error: slice of null pointer +// :13110:9: error: slice of null pointer +// :13121:19: error: slice of null pointer +// :13124:19: error: slice of null pointer +// :13127:19: error: slice of null pointer +// :13138:9: error: slice of null pointer +// :13141:9: error: slice of null pointer +// :13144:9: error: slice of null pointer +// :13147:9: error: slice of null pointer +// :13158:19: error: slice of null pointer +// :13161:19: error: slice of null pointer +// :13164:19: error: slice of null pointer +// :13175:9: error: slice of null pointer +// :13178:20: error: bounds out of order: start 3, end 2 +// :13181:9: error: slice of null pointer +// :13184:20: error: bounds out of order: start 3, end 1 +// :13195:19: error: slice of null pointer +// :13198:19: error: slice of null pointer +// :13201:19: error: slice of null pointer +// :13213:9: error: slice of null pointer +// :13216:9: error: slice of null pointer +// :13219:9: error: slice of null pointer +// :13222:9: error: slice of null pointer +// :13233:19: error: slice of null pointer +// :13236:19: error: slice of null pointer +// :13239:19: error: slice of null pointer +// :13250:9: error: slice of null pointer +// :13253:9: error: slice of null pointer +// :13256:9: error: slice of null pointer +// :13259:9: error: slice of null pointer +// :13270:19: error: slice of null pointer +// :13273:19: error: slice of null pointer +// :13276:19: error: slice of null pointer +// :13287:9: error: slice of null pointer +// :13290:20: error: bounds out of order: start 3, end 2 +// :13293:9: error: slice of null pointer +// :13296:20: error: bounds out of order: start 3, end 1 +// :13307:19: error: slice of null pointer +// :13310:19: error: slice of null pointer +// :13313:19: error: slice of null pointer +// :13324:9: error: slice of null pointer +// :13327:9: error: slice of null pointer +// :13330:9: error: slice of null pointer +// :13333:9: error: slice of null pointer +// :13344:19: error: slice of null pointer +// :13347:19: error: slice of null pointer +// :13350:19: error: slice of null pointer +// :13361:9: error: slice of null pointer +// :13364:9: error: slice of null pointer +// :13367:9: error: slice of null pointer +// :13370:9: error: slice of null pointer +// :13381:19: error: slice of null pointer +// :13384:19: error: slice of null pointer +// :13387:19: error: slice of null pointer +// :13398:9: error: slice of null pointer +// :13401:20: error: bounds out of order: start 3, end 2 +// :13404:9: error: slice of null pointer +// :13407:20: error: bounds out of order: start 3, end 1 +// :13418:19: error: slice of null pointer +// :13421:19: error: slice of null pointer +// :13424:19: error: slice of null pointer +// :13476:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :13479:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :13482:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :13485:28: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :13488:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :13491:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13494:20: error: bounds out of order: start 3, end 2 +// :13497:23: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :13500:20: error: bounds out of order: start 3, end 1 +// :13511:28: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :13514:28: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :13517:28: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :13528:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :13531:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :13534:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :13537:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :13540:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :13543:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :13546:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :13549:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :13552:28: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :13555:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13558:23: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :13561:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :13564:20: error: bounds out of order: start 3, end 1 +// :13575:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :13578:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :13581:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :13594:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :13597:20: error: bounds out of order: start 3, end 2 +// :13600:20: error: bounds out of order: start 3, end 1 +// :13603:28: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :13606:28: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :13609:28: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :13612:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :13615:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :13618:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :13621:28: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :13624:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :13627:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :13630:20: error: bounds out of order: start 3, end 2 +// :13633:23: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :13636:20: error: bounds out of order: start 3, end 1 +// :13647:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :13650:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :13653:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :13666:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :13669:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :13672:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :13675:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :13678:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :13681:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :13684:28: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :13687:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :13690:28: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :13693:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13696:23: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :13699:23: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :13702:20: error: bounds out of order: start 3, end 1 +// :13713:28: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :13716:28: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :13719:28: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :13730:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :13733:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :13736:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :13739:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :13742:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :13745:28: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :13748:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :13751:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :13754:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :13757:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :13768:28: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :13771:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :13774:28: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :13785:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13788:23: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :13791:23: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :13794:23: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :13805:28: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :13808:28: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :13811:28: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :7:21: error: slice end out of bounds: end 3, length 2 +// :10:26: error: slice end out of bounds: end 3, length 2 +// :13:21: error: slice end out of bounds: end 3, length 2 +// :16:26: error: slice end out of bounds: end 3, length 2 +// :19:26: error: slice end out of bounds: end 4, length 2 +// :22:18: error: slice start out of bounds: start 3, length 2 +// :25:18: error: bounds out of order: start 3, end 2 +// :28:21: error: slice end out of bounds: end 3, length 2 +// :31:18: error: bounds out of order: start 3, end 1 +// :35:18: error: slice start out of bounds: start 3, length 2 +// :39:18: error: slice start out of bounds: start 3, length 2 +// :42:26: error: slice end out of bounds: end 5, length 2 +// :45:26: error: slice end out of bounds: end 6, length 2 +// :48:26: error: slice end out of bounds: end 4, length 2 +// :52:18: error: slice start out of bounds: start 3, length 2 +// :56:18: error: slice start out of bounds: start 3, length 2 +// :61:26: error: slice end out of bounds: end 4, length 3 +// :64:18: error: bounds out of order: start 3, end 2 +// :67:18: error: bounds out of order: start 3, end 1 +// :70:26: error: slice end out of bounds: end 5, length 3 +// :73:26: error: slice end out of bounds: end 6, length 3 +// :76:26: error: slice end out of bounds: end 4, length 3 +// :81:21: error: slice end out of bounds: end 2, length 1 +// :84:21: error: slice end out of bounds: end 3, length 1 +// :87:26: error: slice end out of bounds: end 2, length 1 +// :90:26: error: slice end out of bounds: end 3, length 1 +// :93:21: error: slice end out of bounds: end 2, length 1 +// :96:21: error: slice end out of bounds: end 3, length 1 +// :99:26: error: slice end out of bounds: end 3, length 1 +// :102:26: error: slice end out of bounds: end 4, length 1 +// :105:26: error: slice end out of bounds: end 2, length 1 +// :108:18: error: slice start out of bounds: start 3, length 1 +// :111:21: error: slice end out of bounds: end 2, length 1 +// :114:21: error: slice end out of bounds: end 3, length 1 +// :117:18: error: bounds out of order: start 3, end 1 +// :121:18: error: slice start out of bounds: start 3, length 1 +// :125:18: error: slice start out of bounds: start 3, length 1 +// :128:26: error: slice end out of bounds: end 5, length 1 +// :131:26: error: slice end out of bounds: end 6, length 1 +// :134:26: error: slice end out of bounds: end 4, length 1 +// :138:18: error: slice start out of bounds: start 3, length 1 +// :142:18: error: slice start out of bounds: start 3, length 1 +// :147:21: error: slice end out of bounds: end 3, length 2 +// :150:26: error: slice end out of bounds: end 3, length 2 +// :153:21: error: slice end out of bounds: end 3, length 2 +// :156:26: error: slice end out of bounds: end 3, length 2 +// :159:26: error: slice end out of bounds: end 4, length 2 +// :162:18: error: slice start out of bounds: start 3, length 2 +// :165:18: error: bounds out of order: start 3, end 2 +// :168:21: error: slice end out of bounds: end 3, length 2 +// :171:18: error: bounds out of order: start 3, end 1 +// :175:18: error: slice start out of bounds: start 3, length 2 +// :179:18: error: slice start out of bounds: start 3, length 2 +// :182:26: error: slice end out of bounds: end 5, length 2 +// :185:26: error: slice end out of bounds: end 6, length 2 +// :188:26: error: slice end out of bounds: end 4, length 2 +// :192:18: error: slice start out of bounds: start 3, length 2 +// :196:18: error: slice start out of bounds: start 3, length 2 +// :201:26: error: slice end out of bounds: end 4, length 3 +// :204:18: error: bounds out of order: start 3, end 2 +// :207:18: error: bounds out of order: start 3, end 1 +// :210:26: error: slice end out of bounds: end 5, length 3 +// :213:26: error: slice end out of bounds: end 6, length 3 +// :216:26: error: slice end out of bounds: end 4, length 3 +// :221:21: error: slice end out of bounds: end 2, length 1 +// :224:21: error: slice end out of bounds: end 3, length 1 +// :227:26: error: slice end out of bounds: end 2, length 1 +// :230:26: error: slice end out of bounds: end 3, length 1 +// :233:21: error: slice end out of bounds: end 2, length 1 +// :236:21: error: slice end out of bounds: end 3, length 1 +// :239:26: error: slice end out of bounds: end 3, length 1 +// :242:26: error: slice end out of bounds: end 4, length 1 +// :245:26: error: slice end out of bounds: end 2, length 1 +// :248:18: error: slice start out of bounds: start 3, length 1 +// :251:21: error: slice end out of bounds: end 2, length 1 +// :254:21: error: slice end out of bounds: end 3, length 1 +// :257:18: error: bounds out of order: start 3, end 1 +// :261:18: error: slice start out of bounds: start 3, length 1 +// :265:18: error: slice start out of bounds: start 3, length 1 +// :268:26: error: slice end out of bounds: end 5, length 1 +// :271:26: error: slice end out of bounds: end 6, length 1 +// :274:26: error: slice end out of bounds: end 4, length 1 +// :278:18: error: slice start out of bounds: start 3, length 1 +// :282:18: error: slice start out of bounds: start 3, length 1 +// :286:21: error: slice end out of bounds: end 3, length 2 +// :289:26: error: slice end out of bounds: end 3, length 2 +// :292:21: error: slice end out of bounds: end 3, length 2 +// :295:26: error: slice end out of bounds: end 3, length 2 +// :298:26: error: slice end out of bounds: end 4, length 2 +// :301:18: error: slice start out of bounds: start 3, length 2 +// :304:18: error: bounds out of order: start 3, end 2 +// :307:21: error: slice end out of bounds: end 3, length 2 +// :310:18: error: bounds out of order: start 3, end 1 +// :314:18: error: slice start out of bounds: start 3, length 2 +// :318:18: error: slice start out of bounds: start 3, length 2 +// :321:26: error: slice end out of bounds: end 5, length 2 +// :324:26: error: slice end out of bounds: end 6, length 2 +// :327:26: error: slice end out of bounds: end 4, length 2 +// :331:18: error: slice start out of bounds: start 3, length 2 +// :335:18: error: slice start out of bounds: start 3, length 2 +// :339:26: error: slice end out of bounds: end 4, length 3 +// :342:18: error: bounds out of order: start 3, end 2 +// :345:18: error: bounds out of order: start 3, end 1 +// :348:26: error: slice end out of bounds: end 5, length 3 +// :351:26: error: slice end out of bounds: end 6, length 3 +// :354:26: error: slice end out of bounds: end 4, length 3 +// :358:21: error: slice end out of bounds: end 2, length 1 +// :361:21: error: slice end out of bounds: end 3, length 1 +// :364:26: error: slice end out of bounds: end 2, length 1 +// :367:26: error: slice end out of bounds: end 3, length 1 +// :370:21: error: slice end out of bounds: end 2, length 1 +// :373:21: error: slice end out of bounds: end 3, length 1 +// :376:26: error: slice end out of bounds: end 3, length 1 +// :379:26: error: slice end out of bounds: end 4, length 1 +// :382:26: error: slice end out of bounds: end 2, length 1 +// :385:18: error: slice start out of bounds: start 3, length 1 +// :388:21: error: slice end out of bounds: end 2, length 1 +// :391:21: error: slice end out of bounds: end 3, length 1 +// :394:18: error: bounds out of order: start 3, end 1 +// :398:18: error: slice start out of bounds: start 3, length 1 +// :402:18: error: slice start out of bounds: start 3, length 1 +// :405:26: error: slice end out of bounds: end 5, length 1 +// :408:26: error: slice end out of bounds: end 6, length 1 +// :411:26: error: slice end out of bounds: end 4, length 1 +// :415:18: error: slice start out of bounds: start 3, length 1 +// :419:18: error: slice start out of bounds: start 3, length 1 +// :424:18: error: bounds out of order: start 3, end 2 +// :427:18: error: bounds out of order: start 3, end 1 +// :432:19: error: bounds out of order: start 3, end 2 +// :435:19: error: bounds out of order: start 3, end 1 +// :440:19: error: bounds out of order: start 3, end 2 +// :443:19: error: bounds out of order: start 3, end 1 +// :447:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :450:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :453:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :456:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :459:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :462:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :465:19: error: bounds out of order: start 3, end 2 +// :468:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :471:19: error: bounds out of order: start 3, end 1 +// :475:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :479:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :482:27: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :485:27: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :488:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :492:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :496:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :500:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :503:19: error: bounds out of order: start 3, end 2 +// :506:19: error: bounds out of order: start 3, end 1 +// :509:27: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :512:27: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :515:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :519:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :522:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :525:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :528:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :531:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :534:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :537:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :540:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :543:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :546:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :549:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :552:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :555:19: error: bounds out of order: start 3, end 1 +// :559:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :563:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :566:27: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :569:27: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :572:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :576:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :580:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :585:19: error: bounds out of order: start 3, end 2 +// :588:19: error: bounds out of order: start 3, end 1 +// :593:19: error: bounds out of order: start 3, end 2 +// :596:19: error: bounds out of order: start 3, end 1 +// :601:19: error: bounds out of order: start 3, end 2 +// :604:19: error: bounds out of order: start 3, end 1 +// :609:9: error: slice of null pointer +// :612:9: error: slice of null pointer +// :615:9: error: slice of null pointer +// :618:9: error: slice of null pointer +// :622:9: error: slice of null pointer +// :626:9: error: slice of null pointer +// :629:18: error: slice of null pointer +// :632:18: error: slice of null pointer +// :635:18: error: slice of null pointer +// :639:18: error: slice of null pointer +// :643:18: error: slice of null pointer +// :646:9: error: slice of null pointer +// :649:9: error: slice of null pointer +// :652:9: error: slice of null pointer +// :655:9: error: slice of null pointer +// :659:9: error: slice of null pointer +// :663:9: error: slice of null pointer +// :666:18: error: slice of null pointer +// :669:18: error: slice of null pointer +// :672:18: error: slice of null pointer +// :676:18: error: slice of null pointer +// :680:18: error: slice of null pointer +// :683:9: error: slice of null pointer +// :686:19: error: bounds out of order: start 3, end 2 +// :689:9: error: slice of null pointer +// :692:19: error: bounds out of order: start 3, end 1 +// :696:9: error: slice of null pointer +// :700:9: error: slice of null pointer +// :703:18: error: slice of null pointer +// :706:18: error: slice of null pointer +// :709:18: error: slice of null pointer +// :713:18: error: slice of null pointer +// :717:18: error: slice of null pointer +// :721:9: error: slice of null pointer +// :724:9: error: slice of null pointer +// :727:9: error: slice of null pointer +// :730:9: error: slice of null pointer +// :734:9: error: slice of null pointer +// :738:9: error: slice of null pointer +// :741:18: error: slice of null pointer +// :744:18: error: slice of null pointer +// :747:18: error: slice of null pointer +// :751:18: error: slice of null pointer +// :755:18: error: slice of null pointer +// :758:9: error: slice of null pointer +// :761:9: error: slice of null pointer +// :764:9: error: slice of null pointer +// :767:9: error: slice of null pointer +// :771:9: error: slice of null pointer +// :775:9: error: slice of null pointer +// :778:18: error: slice of null pointer +// :781:18: error: slice of null pointer +// :784:18: error: slice of null pointer +// :788:18: error: slice of null pointer +// :792:18: error: slice of null pointer +// :795:9: error: slice of null pointer +// :798:19: error: bounds out of order: start 3, end 2 +// :801:9: error: slice of null pointer +// :804:19: error: bounds out of order: start 3, end 1 +// :808:9: error: slice of null pointer +// :812:9: error: slice of null pointer +// :815:18: error: slice of null pointer +// :818:18: error: slice of null pointer +// :821:18: error: slice of null pointer +// :825:18: error: slice of null pointer +// :829:18: error: slice of null pointer +// :833:9: error: slice of null pointer +// :836:9: error: slice of null pointer +// :839:9: error: slice of null pointer +// :842:9: error: slice of null pointer +// :846:9: error: slice of null pointer +// :850:9: error: slice of null pointer +// :853:18: error: slice of null pointer +// :856:18: error: slice of null pointer +// :859:18: error: slice of null pointer +// :863:18: error: slice of null pointer +// :867:18: error: slice of null pointer +// :870:9: error: slice of null pointer +// :873:9: error: slice of null pointer +// :876:9: error: slice of null pointer +// :879:9: error: slice of null pointer +// :883:9: error: slice of null pointer +// :887:9: error: slice of null pointer +// :890:18: error: slice of null pointer +// :893:18: error: slice of null pointer +// :896:18: error: slice of null pointer +// :900:18: error: slice of null pointer +// :904:18: error: slice of null pointer +// :907:9: error: slice of null pointer +// :910:19: error: bounds out of order: start 3, end 2 +// :913:9: error: slice of null pointer +// :916:19: error: bounds out of order: start 3, end 1 +// :920:9: error: slice of null pointer +// :924:9: error: slice of null pointer +// :927:18: error: slice of null pointer +// :930:18: error: slice of null pointer +// :933:18: error: slice of null pointer +// :937:18: error: slice of null pointer +// :941:18: error: slice of null pointer +// :945:19: error: bounds out of order: start 3, end 2 +// :948:19: error: bounds out of order: start 3, end 1 +// :952:19: error: bounds out of order: start 3, end 2 +// :955:19: error: bounds out of order: start 3, end 1 +// :959:19: error: bounds out of order: start 3, end 2 +// :962:19: error: bounds out of order: start 3, end 1 +// :966:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :969:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :972:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :975:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :978:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :981:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :984:19: error: bounds out of order: start 3, end 2 +// :987:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :990:19: error: bounds out of order: start 3, end 1 +// :994:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :998:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :1001:27: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :1004:27: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :1007:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :1011:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :1015:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :1019:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :1022:19: error: bounds out of order: start 3, end 2 +// :1025:19: error: bounds out of order: start 3, end 1 +// :1028:27: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :1031:27: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :1034:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :1038:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :1041:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :1044:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :1047:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :1050:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :1053:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :1056:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :1059:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :1062:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :1065:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :1068:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :1071:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :1074:19: error: bounds out of order: start 3, end 1 +// :1078:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :1082:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :1085:27: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :1088:27: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :1091:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :1095:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :1099:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :1104:19: error: bounds out of order: start 3, end 2 +// :1107:19: error: bounds out of order: start 3, end 1 +// :1112:19: error: bounds out of order: start 3, end 2 +// :1115:19: error: bounds out of order: start 3, end 1 +// :1120:19: error: bounds out of order: start 3, end 2 +// :1123:19: error: bounds out of order: start 3, end 1 +// :1128:22: error: slice end out of bounds: end 3, length 2 +// :1131:27: error: slice end out of bounds: end 3, length 2 +// :1134:22: error: slice end out of bounds: end 3, length 2 +// :1137:27: error: slice end out of bounds: end 3, length 2 +// :1140:27: error: slice end out of bounds: end 4, length 2 +// :1143:19: error: slice start out of bounds: start 3, length 2 +// :1146:19: error: bounds out of order: start 3, end 2 +// :1149:22: error: slice end out of bounds: end 3, length 2 +// :1152:19: error: bounds out of order: start 3, end 1 +// :1156:19: error: slice start out of bounds: start 3, length 2 +// :1160:19: error: slice start out of bounds: start 3, length 2 +// :1163:27: error: slice end out of bounds: end 5, length 2 +// :1166:27: error: slice end out of bounds: end 6, length 2 +// :1169:27: error: slice end out of bounds: end 4, length 2 +// :1173:19: error: slice start out of bounds: start 3, length 2 +// :1177:19: error: slice start out of bounds: start 3, length 2 +// :1180:24: error: sentinel index always out of bounds +// :1183:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1186:22: error: slice end out of bounds: end 3(+1), length 2 +// :1189:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1192:27: error: slice end out of bounds: end 3(+1), length 2 +// :1195:24: error: sentinel index always out of bounds +// :1198:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1201:22: error: slice end out of bounds: end 3(+1), length 2 +// :1204:27: error: slice end out of bounds: end 3(+1), length 2 +// :1207:27: error: slice end out of bounds: end 4(+1), length 2 +// :1210:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1213:24: error: sentinel index always out of bounds +// :1216:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1219:22: error: slice end out of bounds: end 3(+1), length 2 +// :1222:19: error: bounds out of order: start 3, end 1 +// :1226:19: error: slice start out of bounds: start 3, length 2 +// :1230:19: error: slice start out of bounds: start 3, length 2 +// :1233:27: error: slice end out of bounds: end 5(+1), length 2 +// :1236:27: error: slice end out of bounds: end 6(+1), length 2 +// :1239:27: error: slice end out of bounds: end 4(+1), length 2 +// :1243:19: error: slice start out of bounds: start 3, length 2 +// :1247:19: error: slice start out of bounds: start 3, length 2 +// :1252:22: error: slice end out of bounds: end 3, length 2 +// :1255:27: error: slice end out of bounds: end 3, length 2 +// :1258:22: error: slice end out of bounds: end 3, length 2 +// :1261:27: error: slice end out of bounds: end 3, length 2 +// :1264:27: error: slice end out of bounds: end 4, length 2 +// :1267:19: error: slice start out of bounds: start 3, length 1 +// :1270:19: error: bounds out of order: start 3, end 2 +// :1273:22: error: slice end out of bounds: end 3, length 2 +// :1276:19: error: bounds out of order: start 3, end 1 +// :1280:19: error: slice start out of bounds: start 3, length 2 +// :1284:19: error: slice start out of bounds: start 3, length 2 +// :1287:27: error: slice end out of bounds: end 5, length 2 +// :1290:27: error: slice end out of bounds: end 6, length 2 +// :1293:27: error: slice end out of bounds: end 4, length 2 +// :1297:19: error: slice start out of bounds: start 3, length 2 +// :1301:19: error: slice start out of bounds: start 3, length 2 +// :1304:22: error: slice end out of bounds: end 2, length 1 +// :1307:22: error: slice end out of bounds: end 3, length 1 +// :1310:27: error: slice end out of bounds: end 2, length 1 +// :1313:27: error: slice end out of bounds: end 3, length 1 +// :1316:22: error: slice end out of bounds: end 2, length 1 +// :1319:22: error: slice end out of bounds: end 3, length 1 +// :1322:27: error: slice end out of bounds: end 3, length 1 +// :1325:27: error: slice end out of bounds: end 4, length 1 +// :1328:27: error: slice end out of bounds: end 2, length 1 +// :1331:19: error: slice start out of bounds: start 3, length 1 +// :1334:22: error: slice end out of bounds: end 2, length 1 +// :1337:22: error: slice end out of bounds: end 3, length 1 +// :1340:19: error: bounds out of order: start 3, end 1 +// :1344:19: error: slice start out of bounds: start 3, length 1 +// :1348:19: error: slice start out of bounds: start 3, length 1 +// :1351:27: error: slice end out of bounds: end 5, length 1 +// :1354:27: error: slice end out of bounds: end 6, length 1 +// :1357:27: error: slice end out of bounds: end 4, length 1 +// :1361:19: error: slice start out of bounds: start 3, length 1 +// :1365:19: error: slice start out of bounds: start 3, length 1 +// :1370:27: error: slice end out of bounds: end 4, length 3 +// :1373:19: error: bounds out of order: start 3, end 2 +// :1376:19: error: bounds out of order: start 3, end 1 +// :1379:27: error: slice end out of bounds: end 5, length 3 +// :1382:27: error: slice end out of bounds: end 6, length 3 +// :1385:27: error: slice end out of bounds: end 4, length 3 +// :1388:24: error: sentinel index always out of bounds +// :1391:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :1394:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :1397:24: error: sentinel index always out of bounds +// :1400:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :1403:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :1406:27: error: slice end out of bounds: end 4(+1), length 3 +// :1409:24: error: sentinel index always out of bounds +// :1412:19: error: bounds out of order: start 3, end 2 +// :1415:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :1418:19: error: bounds out of order: start 3, end 1 +// :1422:19: error: slice sentinel always out of bounds: start 3, length 3 +// :1426:19: error: slice sentinel always out of bounds: start 3, length 3 +// :1429:27: error: slice end out of bounds: end 5(+1), length 3 +// :1432:27: error: slice end out of bounds: end 6(+1), length 3 +// :1435:27: error: slice end out of bounds: end 4(+1), length 3 +// :1439:19: error: slice sentinel always out of bounds: start 3, length 3 +// :1443:19: error: slice sentinel always out of bounds: start 3, length 3 +// :1448:27: error: slice end out of bounds: end 4, length 3 +// :1451:19: error: slice start out of bounds: start 3, length 2 +// :1454:19: error: bounds out of order: start 3, end 2 +// :1457:19: error: bounds out of order: start 3, end 1 +// :1460:27: error: slice end out of bounds: end 5, length 3 +// :1463:27: error: slice end out of bounds: end 6, length 3 +// :1466:27: error: slice end out of bounds: end 4, length 3 +// :1469:22: error: slice end out of bounds: end 3, length 2 +// :1472:27: error: slice end out of bounds: end 3, length 2 +// :1475:22: error: slice end out of bounds: end 3, length 2 +// :1478:27: error: slice end out of bounds: end 3, length 2 +// :1481:27: error: slice end out of bounds: end 4, length 2 +// :1484:19: error: slice start out of bounds: start 3, length 2 +// :1487:19: error: bounds out of order: start 3, end 2 +// :1490:22: error: slice end out of bounds: end 3, length 2 +// :1493:19: error: bounds out of order: start 3, end 1 +// :1497:19: error: slice start out of bounds: start 3, length 2 +// :1501:19: error: slice start out of bounds: start 3, length 2 +// :1504:27: error: slice end out of bounds: end 5, length 2 +// :1507:27: error: slice end out of bounds: end 6, length 2 +// :1510:27: error: slice end out of bounds: end 4, length 2 +// :1514:19: error: slice start out of bounds: start 3, length 2 +// :1518:19: error: slice start out of bounds: start 3, length 2 +// :1523:22: error: slice end out of bounds: end 2, length 1 +// :1526:22: error: slice end out of bounds: end 3, length 1 +// :1529:27: error: slice end out of bounds: end 2, length 1 +// :1532:27: error: slice end out of bounds: end 3, length 1 +// :1535:22: error: slice end out of bounds: end 2, length 1 +// :1538:22: error: slice end out of bounds: end 3, length 1 +// :1541:27: error: slice end out of bounds: end 3, length 1 +// :1544:27: error: slice end out of bounds: end 4, length 1 +// :1547:27: error: slice end out of bounds: end 2, length 1 +// :1550:19: error: slice start out of bounds: start 3, length 1 +// :1553:22: error: slice end out of bounds: end 2, length 1 +// :1556:22: error: slice end out of bounds: end 3, length 1 +// :1559:19: error: bounds out of order: start 3, end 1 +// :1563:19: error: slice start out of bounds: start 3, length 1 +// :1567:19: error: slice start out of bounds: start 3, length 1 +// :1570:27: error: slice end out of bounds: end 5, length 1 +// :1573:27: error: slice end out of bounds: end 6, length 1 +// :1576:27: error: slice end out of bounds: end 4, length 1 +// :1580:19: error: slice start out of bounds: start 3, length 1 +// :1584:19: error: slice start out of bounds: start 3, length 1 +// :1587:24: error: sentinel index always out of bounds +// :1590:22: error: slice end out of bounds: end 2(+1), length 1 +// :1593:22: error: slice end out of bounds: end 3(+1), length 1 +// :1596:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :1599:27: error: slice end out of bounds: end 2(+1), length 1 +// :1602:27: error: slice end out of bounds: end 3(+1), length 1 +// :1605:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :1608:24: error: sentinel index always out of bounds +// :1611:22: error: slice end out of bounds: end 2(+1), length 1 +// :1614:22: error: slice end out of bounds: end 3(+1), length 1 +// :1617:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :1621:19: error: slice sentinel always out of bounds: start 1, length 1 +// :1625:19: error: slice sentinel always out of bounds: start 1, length 1 +// :1628:27: error: slice end out of bounds: end 3(+1), length 1 +// :1631:27: error: slice end out of bounds: end 4(+1), length 1 +// :1634:27: error: slice end out of bounds: end 2(+1), length 1 +// :1638:19: error: slice sentinel always out of bounds: start 1, length 1 +// :1642:19: error: slice sentinel always out of bounds: start 1, length 1 +// :1645:24: error: sentinel index always out of bounds +// :1648:22: error: slice end out of bounds: end 2(+1), length 1 +// :1651:22: error: slice end out of bounds: end 3(+1), length 1 +// :1654:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :1658:19: error: slice start out of bounds: start 3, length 1 +// :1662:19: error: slice start out of bounds: start 3, length 1 +// :1665:27: error: slice end out of bounds: end 5(+1), length 1 +// :1668:27: error: slice end out of bounds: end 6(+1), length 1 +// :1671:27: error: slice end out of bounds: end 4(+1), length 1 +// :1675:19: error: slice start out of bounds: start 3, length 1 +// :1679:19: error: slice start out of bounds: start 3, length 1 +// :1684:22: error: slice end out of bounds: end 2, length 1 +// :1687:22: error: slice end out of bounds: end 3, length 1 +// :1690:27: error: slice end out of bounds: end 2, length 1 +// :1693:27: error: slice end out of bounds: end 3, length 1 +// :1696:19: error: slice start out of bounds: start 1, length 0 +// :1699:22: error: slice end out of bounds: end 2, length 1 +// :1702:22: error: slice end out of bounds: end 3, length 1 +// :1705:27: error: slice end out of bounds: end 3, length 1 +// :1708:27: error: slice end out of bounds: end 4, length 1 +// :1711:27: error: slice end out of bounds: end 2, length 1 +// :1714:19: error: slice start out of bounds: start 3, length 0 +// :1717:22: error: slice end out of bounds: end 2, length 1 +// :1720:22: error: slice end out of bounds: end 3, length 1 +// :1723:19: error: bounds out of order: start 3, end 1 +// :1727:19: error: slice start out of bounds: start 3, length 1 +// :1731:19: error: slice start out of bounds: start 3, length 1 +// :1734:27: error: slice end out of bounds: end 5, length 1 +// :1737:27: error: slice end out of bounds: end 6, length 1 +// :1740:27: error: slice end out of bounds: end 4, length 1 +// :1744:19: error: slice start out of bounds: start 3, length 1 +// :1748:19: error: slice start out of bounds: start 3, length 1 +// :1751:22: error: slice end out of bounds: end 2, length 0 +// :1754:22: error: slice end out of bounds: end 3, length 0 +// :1757:22: error: slice end out of bounds: end 1, length 0 +// :1760:27: error: slice end out of bounds: end 2, length 0 +// :1763:27: error: slice end out of bounds: end 3, length 0 +// :1766:27: error: slice end out of bounds: end 1, length 0 +// :1769:19: error: slice start out of bounds: start 1, length 0 +// :1772:22: error: slice end out of bounds: end 2, length 0 +// :1775:22: error: slice end out of bounds: end 3, length 0 +// :1778:22: error: slice end out of bounds: end 1, length 0 +// :1782:19: error: slice start out of bounds: start 1, length 0 +// :1786:19: error: slice start out of bounds: start 1, length 0 +// :1789:27: error: slice end out of bounds: end 3, length 0 +// :1792:27: error: slice end out of bounds: end 4, length 0 +// :1795:27: error: slice end out of bounds: end 2, length 0 +// :1799:19: error: slice start out of bounds: start 1, length 0 +// :1803:19: error: slice start out of bounds: start 1, length 0 +// :1806:19: error: slice start out of bounds: start 3, length 0 +// :1809:22: error: slice end out of bounds: end 2, length 0 +// :1812:22: error: slice end out of bounds: end 3, length 0 +// :1815:22: error: slice end out of bounds: end 1, length 0 +// :1819:19: error: slice start out of bounds: start 3, length 0 +// :1823:19: error: slice start out of bounds: start 3, length 0 +// :1826:27: error: slice end out of bounds: end 5, length 0 +// :1829:27: error: slice end out of bounds: end 6, length 0 +// :1832:27: error: slice end out of bounds: end 4, length 0 +// :1836:19: error: slice start out of bounds: start 3, length 0 +// :1840:19: error: slice start out of bounds: start 3, length 0 +// :1845:22: error: slice end out of bounds: end 3, length 2 +// :1848:27: error: slice end out of bounds: end 3, length 2 +// :1851:22: error: slice end out of bounds: end 3, length 2 +// :1854:27: error: slice end out of bounds: end 3, length 2 +// :1857:27: error: slice end out of bounds: end 4, length 2 +// :1860:19: error: slice start out of bounds: start 3, length 2 +// :1863:19: error: bounds out of order: start 3, end 2 +// :1866:22: error: slice end out of bounds: end 3, length 2 +// :1869:19: error: bounds out of order: start 3, end 1 +// :1873:19: error: slice start out of bounds: start 3, length 2 +// :1877:19: error: slice start out of bounds: start 3, length 2 +// :1880:27: error: slice end out of bounds: end 5, length 2 +// :1883:27: error: slice end out of bounds: end 6, length 2 +// :1886:27: error: slice end out of bounds: end 4, length 2 +// :1890:19: error: slice start out of bounds: start 3, length 2 +// :1894:19: error: slice start out of bounds: start 3, length 2 +// :1897:24: error: sentinel index always out of bounds +// :1900:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1903:22: error: slice end out of bounds: end 3(+1), length 2 +// :1906:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1909:27: error: slice end out of bounds: end 3(+1), length 2 +// :1912:24: error: sentinel index always out of bounds +// :1915:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1918:22: error: slice end out of bounds: end 3(+1), length 2 +// :1921:27: error: slice end out of bounds: end 3(+1), length 2 +// :1924:27: error: slice end out of bounds: end 4(+1), length 2 +// :1927:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1930:24: error: sentinel index always out of bounds +// :1933:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :1936:22: error: slice end out of bounds: end 3(+1), length 2 +// :1939:19: error: bounds out of order: start 3, end 1 +// :1943:19: error: slice start out of bounds: start 3, length 2 +// :1947:19: error: slice start out of bounds: start 3, length 2 +// :1950:27: error: slice end out of bounds: end 5(+1), length 2 +// :1953:27: error: slice end out of bounds: end 6(+1), length 2 +// :1956:27: error: slice end out of bounds: end 4(+1), length 2 +// :1960:19: error: slice start out of bounds: start 3, length 2 +// :1964:19: error: slice start out of bounds: start 3, length 2 +// :1969:22: error: slice end out of bounds: end 3, length 2 +// :1972:27: error: slice end out of bounds: end 3, length 2 +// :1975:22: error: slice end out of bounds: end 3, length 2 +// :1978:27: error: slice end out of bounds: end 3, length 2 +// :1981:27: error: slice end out of bounds: end 4, length 2 +// :1984:19: error: slice start out of bounds: start 3, length 1 +// :1987:19: error: bounds out of order: start 3, end 2 +// :1990:22: error: slice end out of bounds: end 3, length 2 +// :1993:19: error: bounds out of order: start 3, end 1 +// :1997:19: error: slice start out of bounds: start 3, length 2 +// :2001:19: error: slice start out of bounds: start 3, length 2 +// :2004:27: error: slice end out of bounds: end 5, length 2 +// :2007:27: error: slice end out of bounds: end 6, length 2 +// :2010:27: error: slice end out of bounds: end 4, length 2 +// :2014:19: error: slice start out of bounds: start 3, length 2 +// :2018:19: error: slice start out of bounds: start 3, length 2 +// :2021:22: error: slice end out of bounds: end 2, length 1 +// :2024:22: error: slice end out of bounds: end 3, length 1 +// :2027:27: error: slice end out of bounds: end 2, length 1 +// :2030:27: error: slice end out of bounds: end 3, length 1 +// :2033:22: error: slice end out of bounds: end 2, length 1 +// :2036:22: error: slice end out of bounds: end 3, length 1 +// :2039:27: error: slice end out of bounds: end 3, length 1 +// :2042:27: error: slice end out of bounds: end 4, length 1 +// :2045:27: error: slice end out of bounds: end 2, length 1 +// :2048:19: error: slice start out of bounds: start 3, length 1 +// :2051:22: error: slice end out of bounds: end 2, length 1 +// :2054:22: error: slice end out of bounds: end 3, length 1 +// :2057:19: error: bounds out of order: start 3, end 1 +// :2061:19: error: slice start out of bounds: start 3, length 1 +// :2065:19: error: slice start out of bounds: start 3, length 1 +// :2068:27: error: slice end out of bounds: end 5, length 1 +// :2071:27: error: slice end out of bounds: end 6, length 1 +// :2074:27: error: slice end out of bounds: end 4, length 1 +// :2078:19: error: slice start out of bounds: start 3, length 1 +// :2082:19: error: slice start out of bounds: start 3, length 1 +// :2087:27: error: slice end out of bounds: end 4, length 3 +// :2090:19: error: bounds out of order: start 3, end 2 +// :2093:19: error: bounds out of order: start 3, end 1 +// :2096:27: error: slice end out of bounds: end 5, length 3 +// :2099:27: error: slice end out of bounds: end 6, length 3 +// :2102:27: error: slice end out of bounds: end 4, length 3 +// :2105:24: error: sentinel index always out of bounds +// :2108:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2111:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2114:24: error: sentinel index always out of bounds +// :2117:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2120:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2123:27: error: slice end out of bounds: end 4(+1), length 3 +// :2126:24: error: sentinel index always out of bounds +// :2129:19: error: bounds out of order: start 3, end 2 +// :2132:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2135:19: error: bounds out of order: start 3, end 1 +// :2139:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2143:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2146:27: error: slice end out of bounds: end 5(+1), length 3 +// :2149:27: error: slice end out of bounds: end 6(+1), length 3 +// :2152:27: error: slice end out of bounds: end 4(+1), length 3 +// :2156:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2160:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2165:27: error: slice end out of bounds: end 4, length 3 +// :2168:19: error: slice start out of bounds: start 3, length 2 +// :2171:19: error: bounds out of order: start 3, end 2 +// :2174:19: error: bounds out of order: start 3, end 1 +// :2177:27: error: slice end out of bounds: end 5, length 3 +// :2180:27: error: slice end out of bounds: end 6, length 3 +// :2183:27: error: slice end out of bounds: end 4, length 3 +// :2186:22: error: slice end out of bounds: end 3, length 2 +// :2189:27: error: slice end out of bounds: end 3, length 2 +// :2192:22: error: slice end out of bounds: end 3, length 2 +// :2195:27: error: slice end out of bounds: end 3, length 2 +// :2198:27: error: slice end out of bounds: end 4, length 2 +// :2201:19: error: slice start out of bounds: start 3, length 2 +// :2204:19: error: bounds out of order: start 3, end 2 +// :2207:22: error: slice end out of bounds: end 3, length 2 +// :2210:19: error: bounds out of order: start 3, end 1 +// :2214:19: error: slice start out of bounds: start 3, length 2 +// :2218:19: error: slice start out of bounds: start 3, length 2 +// :2221:27: error: slice end out of bounds: end 5, length 2 +// :2224:27: error: slice end out of bounds: end 6, length 2 +// :2227:27: error: slice end out of bounds: end 4, length 2 +// :2231:19: error: slice start out of bounds: start 3, length 2 +// :2235:19: error: slice start out of bounds: start 3, length 2 +// :2240:22: error: slice end out of bounds: end 2, length 1 +// :2243:22: error: slice end out of bounds: end 3, length 1 +// :2246:27: error: slice end out of bounds: end 2, length 1 +// :2249:27: error: slice end out of bounds: end 3, length 1 +// :2252:22: error: slice end out of bounds: end 2, length 1 +// :2255:22: error: slice end out of bounds: end 3, length 1 +// :2258:27: error: slice end out of bounds: end 3, length 1 +// :2261:27: error: slice end out of bounds: end 4, length 1 +// :2264:27: error: slice end out of bounds: end 2, length 1 +// :2267:19: error: slice start out of bounds: start 3, length 1 +// :2270:22: error: slice end out of bounds: end 2, length 1 +// :2273:22: error: slice end out of bounds: end 3, length 1 +// :2276:19: error: bounds out of order: start 3, end 1 +// :2280:19: error: slice start out of bounds: start 3, length 1 +// :2284:19: error: slice start out of bounds: start 3, length 1 +// :2287:27: error: slice end out of bounds: end 5, length 1 +// :2290:27: error: slice end out of bounds: end 6, length 1 +// :2293:27: error: slice end out of bounds: end 4, length 1 +// :2297:19: error: slice start out of bounds: start 3, length 1 +// :2301:19: error: slice start out of bounds: start 3, length 1 +// :2304:24: error: sentinel index always out of bounds +// :2307:22: error: slice end out of bounds: end 2(+1), length 1 +// :2310:22: error: slice end out of bounds: end 3(+1), length 1 +// :2313:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :2316:27: error: slice end out of bounds: end 2(+1), length 1 +// :2319:27: error: slice end out of bounds: end 3(+1), length 1 +// :2322:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :2325:24: error: sentinel index always out of bounds +// :2328:22: error: slice end out of bounds: end 2(+1), length 1 +// :2331:22: error: slice end out of bounds: end 3(+1), length 1 +// :2334:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :2338:19: error: slice sentinel always out of bounds: start 1, length 1 +// :2342:19: error: slice sentinel always out of bounds: start 1, length 1 +// :2345:27: error: slice end out of bounds: end 3(+1), length 1 +// :2348:27: error: slice end out of bounds: end 4(+1), length 1 +// :2351:27: error: slice end out of bounds: end 2(+1), length 1 +// :2355:19: error: slice sentinel always out of bounds: start 1, length 1 +// :2359:19: error: slice sentinel always out of bounds: start 1, length 1 +// :2362:24: error: sentinel index always out of bounds +// :2365:22: error: slice end out of bounds: end 2(+1), length 1 +// :2368:22: error: slice end out of bounds: end 3(+1), length 1 +// :2371:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :2375:19: error: slice start out of bounds: start 3, length 1 +// :2379:19: error: slice start out of bounds: start 3, length 1 +// :2382:27: error: slice end out of bounds: end 5(+1), length 1 +// :2385:27: error: slice end out of bounds: end 6(+1), length 1 +// :2388:27: error: slice end out of bounds: end 4(+1), length 1 +// :2392:19: error: slice start out of bounds: start 3, length 1 +// :2396:19: error: slice start out of bounds: start 3, length 1 +// :2401:22: error: slice end out of bounds: end 2, length 1 +// :2404:22: error: slice end out of bounds: end 3, length 1 +// :2407:27: error: slice end out of bounds: end 2, length 1 +// :2410:27: error: slice end out of bounds: end 3, length 1 +// :2413:19: error: slice start out of bounds: start 1, length 0 +// :2416:22: error: slice end out of bounds: end 2, length 1 +// :2419:22: error: slice end out of bounds: end 3, length 1 +// :2422:27: error: slice end out of bounds: end 3, length 1 +// :2425:27: error: slice end out of bounds: end 4, length 1 +// :2428:27: error: slice end out of bounds: end 2, length 1 +// :2431:19: error: slice start out of bounds: start 3, length 0 +// :2434:22: error: slice end out of bounds: end 2, length 1 +// :2437:22: error: slice end out of bounds: end 3, length 1 +// :2440:19: error: bounds out of order: start 3, end 1 +// :2444:19: error: slice start out of bounds: start 3, length 1 +// :2448:19: error: slice start out of bounds: start 3, length 1 +// :2451:27: error: slice end out of bounds: end 5, length 1 +// :2454:27: error: slice end out of bounds: end 6, length 1 +// :2457:27: error: slice end out of bounds: end 4, length 1 +// :2461:19: error: slice start out of bounds: start 3, length 1 +// :2465:19: error: slice start out of bounds: start 3, length 1 +// :2468:22: error: slice end out of bounds: end 2, length 0 +// :2471:22: error: slice end out of bounds: end 3, length 0 +// :2474:22: error: slice end out of bounds: end 1, length 0 +// :2477:27: error: slice end out of bounds: end 2, length 0 +// :2480:27: error: slice end out of bounds: end 3, length 0 +// :2483:27: error: slice end out of bounds: end 1, length 0 +// :2486:19: error: slice start out of bounds: start 1, length 0 +// :2489:22: error: slice end out of bounds: end 2, length 0 +// :2492:22: error: slice end out of bounds: end 3, length 0 +// :2495:22: error: slice end out of bounds: end 1, length 0 +// :2499:19: error: slice start out of bounds: start 1, length 0 +// :2503:19: error: slice start out of bounds: start 1, length 0 +// :2506:27: error: slice end out of bounds: end 3, length 0 +// :2509:27: error: slice end out of bounds: end 4, length 0 +// :2512:27: error: slice end out of bounds: end 2, length 0 +// :2516:19: error: slice start out of bounds: start 1, length 0 +// :2520:19: error: slice start out of bounds: start 1, length 0 +// :2523:19: error: slice start out of bounds: start 3, length 0 +// :2526:22: error: slice end out of bounds: end 2, length 0 +// :2529:22: error: slice end out of bounds: end 3, length 0 +// :2532:22: error: slice end out of bounds: end 1, length 0 +// :2536:19: error: slice start out of bounds: start 3, length 0 +// :2540:19: error: slice start out of bounds: start 3, length 0 +// :2543:27: error: slice end out of bounds: end 5, length 0 +// :2546:27: error: slice end out of bounds: end 6, length 0 +// :2549:27: error: slice end out of bounds: end 4, length 0 +// :2553:19: error: slice start out of bounds: start 3, length 0 +// :2557:19: error: slice start out of bounds: start 3, length 0 +// :2561:22: error: slice end out of bounds: end 3, length 2 +// :2564:27: error: slice end out of bounds: end 3, length 2 +// :2567:22: error: slice end out of bounds: end 3, length 2 +// :2570:27: error: slice end out of bounds: end 3, length 2 +// :2573:27: error: slice end out of bounds: end 4, length 2 +// :2576:19: error: slice start out of bounds: start 3, length 2 +// :2579:19: error: bounds out of order: start 3, end 2 +// :2582:22: error: slice end out of bounds: end 3, length 2 +// :2585:19: error: bounds out of order: start 3, end 1 +// :2589:19: error: slice start out of bounds: start 3, length 2 +// :2593:19: error: slice start out of bounds: start 3, length 2 +// :2596:27: error: slice end out of bounds: end 5, length 2 +// :2599:27: error: slice end out of bounds: end 6, length 2 +// :2602:27: error: slice end out of bounds: end 4, length 2 +// :2606:19: error: slice start out of bounds: start 3, length 2 +// :2610:19: error: slice start out of bounds: start 3, length 2 +// :2613:24: error: sentinel index always out of bounds +// :2616:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :2619:22: error: slice end out of bounds: end 3(+1), length 2 +// :2622:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :2625:27: error: slice end out of bounds: end 3(+1), length 2 +// :2628:24: error: sentinel index always out of bounds +// :2631:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :2634:22: error: slice end out of bounds: end 3(+1), length 2 +// :2637:27: error: slice end out of bounds: end 3(+1), length 2 +// :2640:27: error: slice end out of bounds: end 4(+1), length 2 +// :2643:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :2646:24: error: sentinel index always out of bounds +// :2649:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :2652:22: error: slice end out of bounds: end 3(+1), length 2 +// :2655:19: error: bounds out of order: start 3, end 1 +// :2659:19: error: slice start out of bounds: start 3, length 2 +// :2663:19: error: slice start out of bounds: start 3, length 2 +// :2666:27: error: slice end out of bounds: end 5(+1), length 2 +// :2669:27: error: slice end out of bounds: end 6(+1), length 2 +// :2672:27: error: slice end out of bounds: end 4(+1), length 2 +// :2676:19: error: slice start out of bounds: start 3, length 2 +// :2680:19: error: slice start out of bounds: start 3, length 2 +// :2684:22: error: slice end out of bounds: end 3, length 2 +// :2687:27: error: slice end out of bounds: end 3, length 2 +// :2690:22: error: slice end out of bounds: end 3, length 2 +// :2693:27: error: slice end out of bounds: end 3, length 2 +// :2696:27: error: slice end out of bounds: end 4, length 2 +// :2699:19: error: slice start out of bounds: start 3, length 1 +// :2702:19: error: bounds out of order: start 3, end 2 +// :2705:22: error: slice end out of bounds: end 3, length 2 +// :2708:19: error: bounds out of order: start 3, end 1 +// :2712:19: error: slice start out of bounds: start 3, length 2 +// :2716:19: error: slice start out of bounds: start 3, length 2 +// :2719:27: error: slice end out of bounds: end 5, length 2 +// :2722:27: error: slice end out of bounds: end 6, length 2 +// :2725:27: error: slice end out of bounds: end 4, length 2 +// :2729:19: error: slice start out of bounds: start 3, length 2 +// :2733:19: error: slice start out of bounds: start 3, length 2 +// :2736:22: error: slice end out of bounds: end 2, length 1 +// :2739:22: error: slice end out of bounds: end 3, length 1 +// :2742:27: error: slice end out of bounds: end 2, length 1 +// :2745:27: error: slice end out of bounds: end 3, length 1 +// :2748:22: error: slice end out of bounds: end 2, length 1 +// :2751:22: error: slice end out of bounds: end 3, length 1 +// :2754:27: error: slice end out of bounds: end 3, length 1 +// :2757:27: error: slice end out of bounds: end 4, length 1 +// :2760:27: error: slice end out of bounds: end 2, length 1 +// :2763:19: error: slice start out of bounds: start 3, length 1 +// :2766:22: error: slice end out of bounds: end 2, length 1 +// :2769:22: error: slice end out of bounds: end 3, length 1 +// :2772:19: error: bounds out of order: start 3, end 1 +// :2776:19: error: slice start out of bounds: start 3, length 1 +// :2780:19: error: slice start out of bounds: start 3, length 1 +// :2783:27: error: slice end out of bounds: end 5, length 1 +// :2786:27: error: slice end out of bounds: end 6, length 1 +// :2789:27: error: slice end out of bounds: end 4, length 1 +// :2793:19: error: slice start out of bounds: start 3, length 1 +// :2797:19: error: slice start out of bounds: start 3, length 1 +// :2801:27: error: slice end out of bounds: end 4, length 3 +// :2804:19: error: bounds out of order: start 3, end 2 +// :2807:19: error: bounds out of order: start 3, end 1 +// :2810:27: error: slice end out of bounds: end 5, length 3 +// :2813:27: error: slice end out of bounds: end 6, length 3 +// :2816:27: error: slice end out of bounds: end 4, length 3 +// :2819:24: error: sentinel index always out of bounds +// :2822:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2825:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2828:24: error: sentinel index always out of bounds +// :2831:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2834:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2837:27: error: slice end out of bounds: end 4(+1), length 3 +// :2840:24: error: sentinel index always out of bounds +// :2843:19: error: bounds out of order: start 3, end 2 +// :2846:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :2849:19: error: bounds out of order: start 3, end 1 +// :2853:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2857:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2860:27: error: slice end out of bounds: end 5(+1), length 3 +// :2863:27: error: slice end out of bounds: end 6(+1), length 3 +// :2866:27: error: slice end out of bounds: end 4(+1), length 3 +// :2870:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2874:19: error: slice sentinel always out of bounds: start 3, length 3 +// :2878:27: error: slice end out of bounds: end 4, length 3 +// :2881:19: error: slice start out of bounds: start 3, length 2 +// :2884:19: error: bounds out of order: start 3, end 2 +// :2887:19: error: bounds out of order: start 3, end 1 +// :2890:27: error: slice end out of bounds: end 5, length 3 +// :2893:27: error: slice end out of bounds: end 6, length 3 +// :2896:27: error: slice end out of bounds: end 4, length 3 +// :2899:22: error: slice end out of bounds: end 3, length 2 +// :2902:27: error: slice end out of bounds: end 3, length 2 +// :2905:22: error: slice end out of bounds: end 3, length 2 +// :2908:27: error: slice end out of bounds: end 3, length 2 +// :2911:27: error: slice end out of bounds: end 4, length 2 +// :2914:19: error: slice start out of bounds: start 3, length 2 +// :2917:19: error: bounds out of order: start 3, end 2 +// :2920:22: error: slice end out of bounds: end 3, length 2 +// :2923:19: error: bounds out of order: start 3, end 1 +// :2927:19: error: slice start out of bounds: start 3, length 2 +// :2931:19: error: slice start out of bounds: start 3, length 2 +// :2934:27: error: slice end out of bounds: end 5, length 2 +// :2937:27: error: slice end out of bounds: end 6, length 2 +// :2940:27: error: slice end out of bounds: end 4, length 2 +// :2944:19: error: slice start out of bounds: start 3, length 2 +// :2948:19: error: slice start out of bounds: start 3, length 2 +// :2952:22: error: slice end out of bounds: end 2, length 1 +// :2955:22: error: slice end out of bounds: end 3, length 1 +// :2958:27: error: slice end out of bounds: end 2, length 1 +// :2961:27: error: slice end out of bounds: end 3, length 1 +// :2964:22: error: slice end out of bounds: end 2, length 1 +// :2967:22: error: slice end out of bounds: end 3, length 1 +// :2970:27: error: slice end out of bounds: end 3, length 1 +// :2973:27: error: slice end out of bounds: end 4, length 1 +// :2976:27: error: slice end out of bounds: end 2, length 1 +// :2979:19: error: slice start out of bounds: start 3, length 1 +// :2982:22: error: slice end out of bounds: end 2, length 1 +// :2985:22: error: slice end out of bounds: end 3, length 1 +// :2988:19: error: bounds out of order: start 3, end 1 +// :2992:19: error: slice start out of bounds: start 3, length 1 +// :2996:19: error: slice start out of bounds: start 3, length 1 +// :2999:27: error: slice end out of bounds: end 5, length 1 +// :3002:27: error: slice end out of bounds: end 6, length 1 +// :3005:27: error: slice end out of bounds: end 4, length 1 +// :3009:19: error: slice start out of bounds: start 3, length 1 +// :3013:19: error: slice start out of bounds: start 3, length 1 +// :3016:24: error: sentinel index always out of bounds +// :3019:22: error: slice end out of bounds: end 2(+1), length 1 +// :3022:22: error: slice end out of bounds: end 3(+1), length 1 +// :3025:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :3028:27: error: slice end out of bounds: end 2(+1), length 1 +// :3031:27: error: slice end out of bounds: end 3(+1), length 1 +// :3034:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :3037:24: error: sentinel index always out of bounds +// :3040:22: error: slice end out of bounds: end 2(+1), length 1 +// :3043:22: error: slice end out of bounds: end 3(+1), length 1 +// :3046:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :3050:19: error: slice sentinel always out of bounds: start 1, length 1 +// :3054:19: error: slice sentinel always out of bounds: start 1, length 1 +// :3057:27: error: slice end out of bounds: end 3(+1), length 1 +// :3060:27: error: slice end out of bounds: end 4(+1), length 1 +// :3063:27: error: slice end out of bounds: end 2(+1), length 1 +// :3067:19: error: slice sentinel always out of bounds: start 1, length 1 +// :3071:19: error: slice sentinel always out of bounds: start 1, length 1 +// :3074:24: error: sentinel index always out of bounds +// :3077:22: error: slice end out of bounds: end 2(+1), length 1 +// :3080:22: error: slice end out of bounds: end 3(+1), length 1 +// :3083:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :3087:19: error: slice start out of bounds: start 3, length 1 +// :3091:19: error: slice start out of bounds: start 3, length 1 +// :3094:27: error: slice end out of bounds: end 5(+1), length 1 +// :3097:27: error: slice end out of bounds: end 6(+1), length 1 +// :3100:27: error: slice end out of bounds: end 4(+1), length 1 +// :3104:19: error: slice start out of bounds: start 3, length 1 +// :3108:19: error: slice start out of bounds: start 3, length 1 +// :3112:22: error: slice end out of bounds: end 2, length 1 +// :3115:22: error: slice end out of bounds: end 3, length 1 +// :3118:27: error: slice end out of bounds: end 2, length 1 +// :3121:27: error: slice end out of bounds: end 3, length 1 +// :3124:19: error: slice start out of bounds: start 1, length 0 +// :3127:22: error: slice end out of bounds: end 2, length 1 +// :3130:22: error: slice end out of bounds: end 3, length 1 +// :3133:27: error: slice end out of bounds: end 3, length 1 +// :3136:27: error: slice end out of bounds: end 4, length 1 +// :3139:27: error: slice end out of bounds: end 2, length 1 +// :3142:19: error: slice start out of bounds: start 3, length 0 +// :3145:22: error: slice end out of bounds: end 2, length 1 +// :3148:22: error: slice end out of bounds: end 3, length 1 +// :3151:19: error: bounds out of order: start 3, end 1 +// :3155:19: error: slice start out of bounds: start 3, length 1 +// :3159:19: error: slice start out of bounds: start 3, length 1 +// :3162:27: error: slice end out of bounds: end 5, length 1 +// :3165:27: error: slice end out of bounds: end 6, length 1 +// :3168:27: error: slice end out of bounds: end 4, length 1 +// :3172:19: error: slice start out of bounds: start 3, length 1 +// :3176:19: error: slice start out of bounds: start 3, length 1 +// :3179:22: error: slice end out of bounds: end 2, length 0 +// :3182:22: error: slice end out of bounds: end 3, length 0 +// :3185:22: error: slice end out of bounds: end 1, length 0 +// :3188:27: error: slice end out of bounds: end 2, length 0 +// :3191:27: error: slice end out of bounds: end 3, length 0 +// :3194:27: error: slice end out of bounds: end 1, length 0 +// :3197:19: error: slice start out of bounds: start 1, length 0 +// :3200:22: error: slice end out of bounds: end 2, length 0 +// :3203:22: error: slice end out of bounds: end 3, length 0 +// :3206:22: error: slice end out of bounds: end 1, length 0 +// :3210:19: error: slice start out of bounds: start 1, length 0 +// :3214:19: error: slice start out of bounds: start 1, length 0 +// :3217:27: error: slice end out of bounds: end 3, length 0 +// :3220:27: error: slice end out of bounds: end 4, length 0 +// :3223:27: error: slice end out of bounds: end 2, length 0 +// :3227:19: error: slice start out of bounds: start 1, length 0 +// :3231:19: error: slice start out of bounds: start 1, length 0 +// :3234:19: error: slice start out of bounds: start 3, length 0 +// :3237:22: error: slice end out of bounds: end 2, length 0 +// :3240:22: error: slice end out of bounds: end 3, length 0 +// :3243:22: error: slice end out of bounds: end 1, length 0 +// :3247:19: error: slice start out of bounds: start 3, length 0 +// :3251:19: error: slice start out of bounds: start 3, length 0 +// :3254:27: error: slice end out of bounds: end 5, length 0 +// :3257:27: error: slice end out of bounds: end 6, length 0 +// :3260:27: error: slice end out of bounds: end 4, length 0 +// :3264:19: error: slice start out of bounds: start 3, length 0 +// :3268:19: error: slice start out of bounds: start 3, length 0 +// :3273:19: error: bounds out of order: start 3, end 2 +// :3276:19: error: bounds out of order: start 3, end 1 +// :3279:24: error: sentinel index always out of bounds +// :3282:24: error: sentinel index always out of bounds +// :3285:24: error: sentinel index always out of bounds +// :3288:19: error: bounds out of order: start 3, end 2 +// :3291:19: error: bounds out of order: start 3, end 1 +// :3296:19: error: bounds out of order: start 3, end 2 +// :3299:19: error: bounds out of order: start 3, end 1 +// :3302:19: error: bounds out of order: start 3, end 2 +// :3305:19: error: bounds out of order: start 3, end 1 +// :3310:19: error: bounds out of order: start 3, end 2 +// :3313:19: error: bounds out of order: start 3, end 1 +// :3316:24: error: sentinel index always out of bounds +// :3319:24: error: sentinel index always out of bounds +// :3322:24: error: sentinel index always out of bounds +// :3325:19: error: bounds out of order: start 3, end 2 +// :3328:19: error: bounds out of order: start 3, end 1 +// :3333:19: error: bounds out of order: start 3, end 2 +// :3336:19: error: bounds out of order: start 3, end 1 +// :3339:19: error: bounds out of order: start 3, end 2 +// :3342:19: error: bounds out of order: start 3, end 1 +// :3347:19: error: bounds out of order: start 3, end 2 +// :3350:19: error: bounds out of order: start 3, end 1 +// :3353:24: error: sentinel index always out of bounds +// :3356:24: error: sentinel index always out of bounds +// :3359:24: error: sentinel index always out of bounds +// :3362:19: error: bounds out of order: start 3, end 2 +// :3365:19: error: bounds out of order: start 3, end 1 +// :3370:19: error: bounds out of order: start 3, end 2 +// :3373:19: error: bounds out of order: start 3, end 1 +// :3376:19: error: bounds out of order: start 3, end 2 +// :3379:19: error: bounds out of order: start 3, end 1 +// :3383:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3386:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3389:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3392:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3395:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :3398:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3401:19: error: bounds out of order: start 3, end 2 +// :3404:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3407:19: error: bounds out of order: start 3, end 1 +// :3411:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3415:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3418:27: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :3421:27: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :3424:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :3428:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3432:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3435:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3438:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3441:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3444:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3447:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3450:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3453:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3456:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :3459:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3462:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3465:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3468:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3471:19: error: bounds out of order: start 3, end 1 +// :3475:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3479:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3482:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :3485:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :3488:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :3492:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3496:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3500:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3503:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3506:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3509:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3512:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :3515:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3518:19: error: bounds out of order: start 3, end 2 +// :3521:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :3524:19: error: bounds out of order: start 3, end 1 +// :3528:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3532:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3535:27: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :3538:27: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :3541:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :3545:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3549:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3552:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3555:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3558:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3561:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3564:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3567:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3570:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3573:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :3576:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3579:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3582:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :3585:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :3588:19: error: bounds out of order: start 3, end 1 +// :3592:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3596:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3599:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :3602:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :3605:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :3609:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3613:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :3617:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :3620:19: error: bounds out of order: start 3, end 2 +// :3623:19: error: bounds out of order: start 3, end 1 +// :3626:27: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :3629:27: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :3632:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :3635:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3638:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3641:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3644:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3647:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :3650:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3653:19: error: bounds out of order: start 3, end 2 +// :3656:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3659:19: error: bounds out of order: start 3, end 1 +// :3663:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3667:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3670:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :3673:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :3676:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :3680:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3684:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3688:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :3691:19: error: bounds out of order: start 3, end 2 +// :3694:19: error: bounds out of order: start 3, end 1 +// :3697:27: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :3700:27: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :3703:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :3706:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3709:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3712:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3715:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3718:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :3721:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3724:19: error: bounds out of order: start 3, end 2 +// :3727:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :3730:19: error: bounds out of order: start 3, end 1 +// :3734:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3738:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3741:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :3744:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :3747:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :3751:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3755:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :3759:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3762:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3765:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3768:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3771:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3774:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3777:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3780:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :3783:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3786:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3789:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3792:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3795:19: error: bounds out of order: start 3, end 1 +// :3799:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3803:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3806:27: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :3809:27: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :3812:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :3816:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3820:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3823:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3826:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3829:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3832:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3835:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3838:27: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3841:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :3844:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3847:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3850:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3854:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :3858:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :3861:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3864:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :3867:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3871:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :3875:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :3878:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3881:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3884:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3887:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3891:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3895:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3898:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :3901:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :3904:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :3908:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3912:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3916:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3919:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3922:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3925:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3928:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3931:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3934:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3937:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :3940:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3943:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3946:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :3949:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :3952:19: error: bounds out of order: start 3, end 1 +// :3956:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3960:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3963:27: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :3966:27: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :3969:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :3973:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3977:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :3980:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3983:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3986:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3989:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :3992:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :3995:27: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :3998:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :4001:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :4004:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :4007:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :4011:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :4015:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :4018:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :4021:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :4024:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :4028:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :4032:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :4035:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :4038:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :4041:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :4044:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :4048:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :4052:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :4055:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :4058:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :4061:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :4065:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :4069:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :4074:19: error: bounds out of order: start 3, end 2 +// :4077:19: error: bounds out of order: start 3, end 1 +// :4080:19: error: bounds out of order: start 3, end 2 +// :4083:19: error: bounds out of order: start 3, end 1 +// :4088:19: error: bounds out of order: start 3, end 2 +// :4091:19: error: bounds out of order: start 3, end 1 +// :4094:19: error: bounds out of order: start 3, end 2 +// :4097:19: error: bounds out of order: start 3, end 1 +// :4102:19: error: bounds out of order: start 3, end 2 +// :4105:19: error: bounds out of order: start 3, end 1 +// :4108:19: error: bounds out of order: start 3, end 2 +// :4111:19: error: bounds out of order: start 3, end 1 +// :4116:19: error: bounds out of order: start 3, end 2 +// :4119:19: error: bounds out of order: start 3, end 1 +// :4122:19: error: bounds out of order: start 3, end 2 +// :4125:19: error: bounds out of order: start 3, end 1 +// :4130:19: error: bounds out of order: start 3, end 2 +// :4133:19: error: bounds out of order: start 3, end 1 +// :4136:19: error: bounds out of order: start 3, end 2 +// :4139:19: error: bounds out of order: start 3, end 1 +// :4144:19: error: bounds out of order: start 3, end 2 +// :4147:19: error: bounds out of order: start 3, end 1 +// :4150:19: error: bounds out of order: start 3, end 2 +// :4153:19: error: bounds out of order: start 3, end 1 +// :4157:9: error: slice of null pointer +// :4160:9: error: slice of null pointer +// :4163:9: error: slice of null pointer +// :4166:9: error: slice of null pointer +// :4170:9: error: slice of null pointer +// :4174:9: error: slice of null pointer +// :4177:18: error: slice of null pointer +// :4180:18: error: slice of null pointer +// :4183:18: error: slice of null pointer +// :4187:18: error: slice of null pointer +// :4191:18: error: slice of null pointer +// :4194:9: error: slice of null pointer +// :4197:9: error: slice of null pointer +// :4200:9: error: slice of null pointer +// :4203:9: error: slice of null pointer +// :4207:9: error: slice of null pointer +// :4211:9: error: slice of null pointer +// :4214:18: error: slice of null pointer +// :4217:18: error: slice of null pointer +// :4220:18: error: slice of null pointer +// :4224:18: error: slice of null pointer +// :4228:18: error: slice of null pointer +// :4231:9: error: slice of null pointer +// :4234:19: error: bounds out of order: start 3, end 2 +// :4237:9: error: slice of null pointer +// :4240:19: error: bounds out of order: start 3, end 1 +// :4244:9: error: slice of null pointer +// :4248:9: error: slice of null pointer +// :4251:18: error: slice of null pointer +// :4254:18: error: slice of null pointer +// :4257:18: error: slice of null pointer +// :4261:18: error: slice of null pointer +// :4265:18: error: slice of null pointer +// :4268:9: error: slice of null pointer +// :4271:9: error: slice of null pointer +// :4274:9: error: slice of null pointer +// :4277:9: error: slice of null pointer +// :4281:9: error: slice of null pointer +// :4285:9: error: slice of null pointer +// :4288:18: error: slice of null pointer +// :4291:18: error: slice of null pointer +// :4294:18: error: slice of null pointer +// :4298:18: error: slice of null pointer +// :4302:18: error: slice of null pointer +// :4305:9: error: slice of null pointer +// :4308:9: error: slice of null pointer +// :4311:9: error: slice of null pointer +// :4314:9: error: slice of null pointer +// :4318:9: error: slice of null pointer +// :4322:9: error: slice of null pointer +// :4325:18: error: slice of null pointer +// :4328:18: error: slice of null pointer +// :4331:18: error: slice of null pointer +// :4335:18: error: slice of null pointer +// :4339:18: error: slice of null pointer +// :4342:9: error: slice of null pointer +// :4345:19: error: bounds out of order: start 3, end 2 +// :4348:9: error: slice of null pointer +// :4351:19: error: bounds out of order: start 3, end 1 +// :4355:9: error: slice of null pointer +// :4359:9: error: slice of null pointer +// :4362:18: error: slice of null pointer +// :4365:18: error: slice of null pointer +// :4368:18: error: slice of null pointer +// :4372:18: error: slice of null pointer +// :4376:18: error: slice of null pointer +// :4380:9: error: slice of null pointer +// :4383:9: error: slice of null pointer +// :4386:9: error: slice of null pointer +// :4389:9: error: slice of null pointer +// :4393:9: error: slice of null pointer +// :4397:9: error: slice of null pointer +// :4400:18: error: slice of null pointer +// :4403:18: error: slice of null pointer +// :4406:18: error: slice of null pointer +// :4410:18: error: slice of null pointer +// :4414:18: error: slice of null pointer +// :4417:9: error: slice of null pointer +// :4420:9: error: slice of null pointer +// :4423:9: error: slice of null pointer +// :4426:9: error: slice of null pointer +// :4430:9: error: slice of null pointer +// :4434:9: error: slice of null pointer +// :4437:18: error: slice of null pointer +// :4440:18: error: slice of null pointer +// :4443:18: error: slice of null pointer +// :4447:18: error: slice of null pointer +// :4451:18: error: slice of null pointer +// :4454:9: error: slice of null pointer +// :4457:19: error: bounds out of order: start 3, end 2 +// :4460:9: error: slice of null pointer +// :4463:19: error: bounds out of order: start 3, end 1 +// :4467:9: error: slice of null pointer +// :4471:9: error: slice of null pointer +// :4474:18: error: slice of null pointer +// :4477:18: error: slice of null pointer +// :4480:18: error: slice of null pointer +// :4484:18: error: slice of null pointer +// :4488:18: error: slice of null pointer +// :4491:9: error: slice of null pointer +// :4494:9: error: slice of null pointer +// :4497:9: error: slice of null pointer +// :4500:9: error: slice of null pointer +// :4504:9: error: slice of null pointer +// :4508:9: error: slice of null pointer +// :4511:18: error: slice of null pointer +// :4514:18: error: slice of null pointer +// :4517:18: error: slice of null pointer +// :4521:18: error: slice of null pointer +// :4525:18: error: slice of null pointer +// :4528:9: error: slice of null pointer +// :4531:9: error: slice of null pointer +// :4534:9: error: slice of null pointer +// :4537:9: error: slice of null pointer +// :4541:9: error: slice of null pointer +// :4545:9: error: slice of null pointer +// :4548:18: error: slice of null pointer +// :4551:18: error: slice of null pointer +// :4554:18: error: slice of null pointer +// :4558:18: error: slice of null pointer +// :4562:18: error: slice of null pointer +// :4565:9: error: slice of null pointer +// :4568:19: error: bounds out of order: start 3, end 2 +// :4571:9: error: slice of null pointer +// :4574:19: error: bounds out of order: start 3, end 1 +// :4578:9: error: slice of null pointer +// :4582:9: error: slice of null pointer +// :4585:18: error: slice of null pointer +// :4588:18: error: slice of null pointer +// :4591:18: error: slice of null pointer +// :4595:18: error: slice of null pointer +// :4599:18: error: slice of null pointer +// :4603:9: error: slice of null pointer +// :4606:9: error: slice of null pointer +// :4609:9: error: slice of null pointer +// :4612:9: error: slice of null pointer +// :4616:9: error: slice of null pointer +// :4620:9: error: slice of null pointer +// :4623:18: error: slice of null pointer +// :4626:18: error: slice of null pointer +// :4629:18: error: slice of null pointer +// :4633:18: error: slice of null pointer +// :4637:18: error: slice of null pointer +// :4640:9: error: slice of null pointer +// :4643:9: error: slice of null pointer +// :4646:9: error: slice of null pointer +// :4649:9: error: slice of null pointer +// :4653:9: error: slice of null pointer +// :4657:9: error: slice of null pointer +// :4660:18: error: slice of null pointer +// :4663:18: error: slice of null pointer +// :4666:18: error: slice of null pointer +// :4670:18: error: slice of null pointer +// :4674:18: error: slice of null pointer +// :4677:9: error: slice of null pointer +// :4680:19: error: bounds out of order: start 3, end 2 +// :4683:9: error: slice of null pointer +// :4686:19: error: bounds out of order: start 3, end 1 +// :4690:9: error: slice of null pointer +// :4694:9: error: slice of null pointer +// :4697:18: error: slice of null pointer +// :4700:18: error: slice of null pointer +// :4703:18: error: slice of null pointer +// :4707:18: error: slice of null pointer +// :4711:18: error: slice of null pointer +// :4714:9: error: slice of null pointer +// :4717:9: error: slice of null pointer +// :4720:9: error: slice of null pointer +// :4723:9: error: slice of null pointer +// :4727:9: error: slice of null pointer +// :4731:9: error: slice of null pointer +// :4734:18: error: slice of null pointer +// :4737:18: error: slice of null pointer +// :4740:18: error: slice of null pointer +// :4744:18: error: slice of null pointer +// :4748:18: error: slice of null pointer +// :4751:9: error: slice of null pointer +// :4754:9: error: slice of null pointer +// :4757:9: error: slice of null pointer +// :4760:9: error: slice of null pointer +// :4764:9: error: slice of null pointer +// :4768:9: error: slice of null pointer +// :4771:18: error: slice of null pointer +// :4774:18: error: slice of null pointer +// :4777:18: error: slice of null pointer +// :4781:18: error: slice of null pointer +// :4785:18: error: slice of null pointer +// :4788:9: error: slice of null pointer +// :4791:19: error: bounds out of order: start 3, end 2 +// :4794:9: error: slice of null pointer +// :4797:19: error: bounds out of order: start 3, end 1 +// :4801:9: error: slice of null pointer +// :4805:9: error: slice of null pointer +// :4808:18: error: slice of null pointer +// :4811:18: error: slice of null pointer +// :4814:18: error: slice of null pointer +// :4818:18: error: slice of null pointer +// :4822:18: error: slice of null pointer +// :4826:19: error: bounds out of order: start 3, end 2 +// :4829:19: error: bounds out of order: start 3, end 1 +// :4832:19: error: bounds out of order: start 3, end 2 +// :4835:19: error: bounds out of order: start 3, end 1 +// :4839:19: error: bounds out of order: start 3, end 2 +// :4842:19: error: bounds out of order: start 3, end 1 +// :4845:19: error: bounds out of order: start 3, end 2 +// :4848:19: error: bounds out of order: start 3, end 1 +// :4852:19: error: bounds out of order: start 3, end 2 +// :4855:19: error: bounds out of order: start 3, end 1 +// :4858:19: error: bounds out of order: start 3, end 2 +// :4861:19: error: bounds out of order: start 3, end 1 +// :4865:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :4868:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :4871:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :4874:27: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :4877:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :4880:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4883:19: error: bounds out of order: start 3, end 2 +// :4886:22: error: slice end out of bounds of reinterpreted memory: end 3, length 2 +// :4889:19: error: bounds out of order: start 3, end 1 +// :4893:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4897:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4900:27: error: slice end out of bounds of reinterpreted memory: end 5, length 2 +// :4903:27: error: slice end out of bounds of reinterpreted memory: end 6, length 2 +// :4906:27: error: slice end out of bounds of reinterpreted memory: end 4, length 2 +// :4910:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4914:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4917:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :4920:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :4923:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :4926:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :4929:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :4932:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :4935:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :4938:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :4941:27: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :4944:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4947:22: error: slice sentinel out of bounds of reinterpreted memory: end 2(+1), length 2 +// :4950:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 2 +// :4953:19: error: bounds out of order: start 3, end 1 +// :4957:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4961:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4964:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 2 +// :4967:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 2 +// :4970:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 2 +// :4974:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4978:19: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :4982:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :4985:19: error: bounds out of order: start 3, end 2 +// :4988:19: error: bounds out of order: start 3, end 1 +// :4991:27: error: slice end out of bounds of reinterpreted memory: end 5, length 3 +// :4994:27: error: slice end out of bounds of reinterpreted memory: end 6, length 3 +// :4997:27: error: slice end out of bounds of reinterpreted memory: end 4, length 3 +// :5000:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :5003:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :5006:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :5009:27: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :5012:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :5015:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :5018:19: error: bounds out of order: start 3, end 2 +// :5021:22: error: slice sentinel out of bounds of reinterpreted memory: end 3(+1), length 3 +// :5024:19: error: bounds out of order: start 3, end 1 +// :5028:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :5032:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :5035:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 3 +// :5038:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 3 +// :5041:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 3 +// :5045:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :5049:19: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :5053:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :5056:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :5059:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :5062:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :5065:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :5068:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :5071:27: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :5074:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :5077:27: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :5080:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5083:22: error: slice end out of bounds of reinterpreted memory: end 2, length 1 +// :5086:22: error: slice end out of bounds of reinterpreted memory: end 3, length 1 +// :5089:19: error: bounds out of order: start 3, end 1 +// :5093:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5097:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5100:27: error: slice end out of bounds of reinterpreted memory: end 5, length 1 +// :5103:27: error: slice end out of bounds of reinterpreted memory: end 6, length 1 +// :5106:27: error: slice end out of bounds of reinterpreted memory: end 4, length 1 +// :5110:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5114:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5117:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :5120:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :5123:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :5126:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :5129:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :5132:27: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :5135:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :5138:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :5141:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :5144:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :5148:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :5152:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :5155:27: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :5158:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :5161:27: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :5165:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :5169:19: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :5172:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5175:22: error: slice end out of bounds of reinterpreted memory: end 2(+1), length 1 +// :5178:22: error: slice end out of bounds of reinterpreted memory: end 3(+1), length 1 +// :5181:22: error: slice sentinel out of bounds of reinterpreted memory: end 1(+1), length 1 +// :5185:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5189:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5192:27: error: slice end out of bounds of reinterpreted memory: end 5(+1), length 1 +// :5195:27: error: slice end out of bounds of reinterpreted memory: end 6(+1), length 1 +// :5198:27: error: slice end out of bounds of reinterpreted memory: end 4(+1), length 1 +// :5202:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5206:19: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :5211:19: error: bounds out of order: start 3, end 2 +// :5214:19: error: bounds out of order: start 3, end 1 +// :5217:19: error: bounds out of order: start 3, end 2 +// :5220:19: error: bounds out of order: start 3, end 1 +// :5225:19: error: bounds out of order: start 3, end 2 +// :5228:19: error: bounds out of order: start 3, end 1 +// :5231:19: error: bounds out of order: start 3, end 2 +// :5234:19: error: bounds out of order: start 3, end 1 +// :5239:19: error: bounds out of order: start 3, end 2 +// :5242:19: error: bounds out of order: start 3, end 1 +// :5245:19: error: bounds out of order: start 3, end 2 +// :5248:19: error: bounds out of order: start 3, end 1 +// :5281:19: error: slice start out of bounds: start 3, length 2 +// :5285:19: error: slice start out of bounds: start 3, length 2 +// :5298:19: error: slice start out of bounds: start 3, length 2 +// :5302:19: error: slice start out of bounds: start 3, length 2 +// :5360:19: error: slice start out of bounds: start 3, length 2 +// :5364:19: error: slice start out of bounds: start 3, length 2 +// :5377:19: error: slice start out of bounds: start 3, length 2 +// :5381:19: error: slice start out of bounds: start 3, length 2 +// :5414:19: error: slice start out of bounds: start 3, length 2 +// :5418:19: error: slice start out of bounds: start 3, length 2 +// :5431:19: error: slice start out of bounds: start 3, length 2 +// :5435:19: error: slice start out of bounds: start 3, length 2 +// :5493:19: error: slice start out of bounds: start 3, length 1 +// :5497:19: error: slice start out of bounds: start 3, length 1 +// :5510:19: error: slice start out of bounds: start 3, length 1 +// :5514:19: error: slice start out of bounds: start 3, length 1 +// :5592:19: error: slice sentinel always out of bounds: start 3, length 3 +// :5596:19: error: slice sentinel always out of bounds: start 3, length 3 +// :5609:19: error: slice sentinel always out of bounds: start 3, length 3 +// :5613:19: error: slice sentinel always out of bounds: start 3, length 3 +// :5694:19: error: slice start out of bounds: start 3, length 2 +// :5698:19: error: slice start out of bounds: start 3, length 2 +// :5711:19: error: slice start out of bounds: start 3, length 2 +// :5715:19: error: slice start out of bounds: start 3, length 2 +// :5760:19: error: slice start out of bounds: start 3, length 1 +// :5764:19: error: slice start out of bounds: start 3, length 1 +// :5777:19: error: slice start out of bounds: start 3, length 1 +// :5781:19: error: slice start out of bounds: start 3, length 1 +// :5818:19: error: slice sentinel always out of bounds: start 1, length 1 +// :5822:19: error: slice sentinel always out of bounds: start 1, length 1 +// :5835:19: error: slice sentinel always out of bounds: start 1, length 1 +// :5839:19: error: slice sentinel always out of bounds: start 1, length 1 +// :5855:19: error: slice start out of bounds: start 3, length 1 +// :5859:19: error: slice start out of bounds: start 3, length 1 +// :5872:19: error: slice start out of bounds: start 3, length 1 +// :5876:19: error: slice start out of bounds: start 3, length 1 +// :5924:19: error: slice start out of bounds: start 3, length 1 +// :5928:19: error: slice start out of bounds: start 3, length 1 +// :5941:19: error: slice start out of bounds: start 3, length 1 +// :5945:19: error: slice start out of bounds: start 3, length 1 +// :5982:19: error: slice start out of bounds: start 1, length 0 +// :5986:19: error: slice start out of bounds: start 1, length 0 +// :5999:19: error: slice start out of bounds: start 1, length 0 +// :6003:19: error: slice start out of bounds: start 1, length 0 +// :6019:19: error: slice start out of bounds: start 3, length 0 +// :6023:19: error: slice start out of bounds: start 3, length 0 +// :6036:19: error: slice start out of bounds: start 3, length 0 +// :6040:19: error: slice start out of bounds: start 3, length 0 +// :6045:22: error: slice end out of bounds: end 3, length 2 +// :6048:27: error: slice end out of bounds: end 3, length 2 +// :6051:22: error: slice end out of bounds: end 3, length 2 +// :6054:27: error: slice end out of bounds: end 3, length 2 +// :6057:27: error: slice end out of bounds: end 4, length 2 +// :6060:19: error: slice start out of bounds: start 3, length 2 +// :6063:19: error: bounds out of order: start 3, end 2 +// :6066:22: error: slice end out of bounds: end 3, length 2 +// :6069:19: error: bounds out of order: start 3, end 1 +// :6073:19: error: slice start out of bounds: start 3, length 2 +// :6077:19: error: slice start out of bounds: start 3, length 2 +// :6080:27: error: slice end out of bounds: end 5, length 2 +// :6083:27: error: slice end out of bounds: end 6, length 2 +// :6086:27: error: slice end out of bounds: end 4, length 2 +// :6090:19: error: slice start out of bounds: start 3, length 2 +// :6094:19: error: slice start out of bounds: start 3, length 2 +// :6097:24: error: sentinel index always out of bounds +// :6100:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6103:22: error: slice end out of bounds: end 3(+1), length 2 +// :6106:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6109:27: error: slice end out of bounds: end 3(+1), length 2 +// :6112:24: error: sentinel index always out of bounds +// :6115:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6118:22: error: slice end out of bounds: end 3(+1), length 2 +// :6121:27: error: slice end out of bounds: end 3(+1), length 2 +// :6124:27: error: slice end out of bounds: end 4(+1), length 2 +// :6127:27: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6130:24: error: sentinel index always out of bounds +// :6133:22: error: slice sentinel out of bounds: end 2(+1), length 2 +// :6136:22: error: slice end out of bounds: end 3(+1), length 2 +// :6139:19: error: bounds out of order: start 3, end 1 +// :6143:19: error: slice start out of bounds: start 3, length 2 +// :6147:19: error: slice start out of bounds: start 3, length 2 +// :6150:27: error: slice end out of bounds: end 5(+1), length 2 +// :6153:27: error: slice end out of bounds: end 6(+1), length 2 +// :6156:27: error: slice end out of bounds: end 4(+1), length 2 +// :6160:19: error: slice start out of bounds: start 3, length 2 +// :6164:19: error: slice start out of bounds: start 3, length 2 +// :6169:22: error: slice end out of bounds: end 3, length 2 +// :6172:27: error: slice end out of bounds: end 3, length 2 +// :6175:22: error: slice end out of bounds: end 3, length 2 +// :6178:27: error: slice end out of bounds: end 3, length 2 +// :6181:27: error: slice end out of bounds: end 4, length 2 +// :6184:19: error: slice start out of bounds: start 3, length 1 +// :6187:19: error: bounds out of order: start 3, end 2 +// :6190:22: error: slice end out of bounds: end 3, length 2 +// :6193:19: error: bounds out of order: start 3, end 1 +// :6197:19: error: slice start out of bounds: start 3, length 2 +// :6201:19: error: slice start out of bounds: start 3, length 2 +// :6204:27: error: slice end out of bounds: end 5, length 2 +// :6207:27: error: slice end out of bounds: end 6, length 2 +// :6210:27: error: slice end out of bounds: end 4, length 2 +// :6214:19: error: slice start out of bounds: start 3, length 2 +// :6218:19: error: slice start out of bounds: start 3, length 2 +// :6221:22: error: slice end out of bounds: end 2, length 1 +// :6224:22: error: slice end out of bounds: end 3, length 1 +// :6227:27: error: slice end out of bounds: end 2, length 1 +// :6230:27: error: slice end out of bounds: end 3, length 1 +// :6233:22: error: slice end out of bounds: end 2, length 1 +// :6236:22: error: slice end out of bounds: end 3, length 1 +// :6239:27: error: slice end out of bounds: end 3, length 1 +// :6242:27: error: slice end out of bounds: end 4, length 1 +// :6245:27: error: slice end out of bounds: end 2, length 1 +// :6248:19: error: slice start out of bounds: start 3, length 1 +// :6251:22: error: slice end out of bounds: end 2, length 1 +// :6254:22: error: slice end out of bounds: end 3, length 1 +// :6257:19: error: bounds out of order: start 3, end 1 +// :6261:19: error: slice start out of bounds: start 3, length 1 +// :6265:19: error: slice start out of bounds: start 3, length 1 +// :6268:27: error: slice end out of bounds: end 5, length 1 +// :6271:27: error: slice end out of bounds: end 6, length 1 +// :6274:27: error: slice end out of bounds: end 4, length 1 +// :6278:19: error: slice start out of bounds: start 3, length 1 +// :6282:19: error: slice start out of bounds: start 3, length 1 +// :6287:27: error: slice end out of bounds: end 4, length 3 +// :6290:19: error: bounds out of order: start 3, end 2 +// :6293:19: error: bounds out of order: start 3, end 1 +// :6296:27: error: slice end out of bounds: end 5, length 3 +// :6299:27: error: slice end out of bounds: end 6, length 3 +// :6302:27: error: slice end out of bounds: end 4, length 3 +// :6305:24: error: sentinel index always out of bounds +// :6308:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :6311:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :6314:24: error: sentinel index always out of bounds +// :6317:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :6320:27: error: slice sentinel out of bounds: end 3(+1), length 3 +// :6323:27: error: slice end out of bounds: end 4(+1), length 3 +// :6326:24: error: sentinel index always out of bounds +// :6329:19: error: bounds out of order: start 3, end 2 +// :6332:22: error: slice sentinel out of bounds: end 3(+1), length 3 +// :6335:19: error: bounds out of order: start 3, end 1 +// :6339:19: error: slice sentinel always out of bounds: start 3, length 3 +// :6343:19: error: slice sentinel always out of bounds: start 3, length 3 +// :6346:27: error: slice end out of bounds: end 5(+1), length 3 +// :6349:27: error: slice end out of bounds: end 6(+1), length 3 +// :6352:27: error: slice end out of bounds: end 4(+1), length 3 +// :6356:19: error: slice sentinel always out of bounds: start 3, length 3 +// :6360:19: error: slice sentinel always out of bounds: start 3, length 3 +// :6365:27: error: slice end out of bounds: end 4, length 3 +// :6368:19: error: slice start out of bounds: start 3, length 2 +// :6371:19: error: bounds out of order: start 3, end 2 +// :6374:19: error: bounds out of order: start 3, end 1 +// :6377:27: error: slice end out of bounds: end 5, length 3 +// :6380:27: error: slice end out of bounds: end 6, length 3 +// :6383:27: error: slice end out of bounds: end 4, length 3 +// :6386:22: error: slice end out of bounds: end 3, length 2 +// :6389:27: error: slice end out of bounds: end 3, length 2 +// :6392:22: error: slice end out of bounds: end 3, length 2 +// :6395:27: error: slice end out of bounds: end 3, length 2 +// :6398:27: error: slice end out of bounds: end 4, length 2 +// :6401:19: error: slice start out of bounds: start 3, length 2 +// :6404:19: error: bounds out of order: start 3, end 2 +// :6407:22: error: slice end out of bounds: end 3, length 2 +// :6410:19: error: bounds out of order: start 3, end 1 +// :6414:19: error: slice start out of bounds: start 3, length 2 +// :6418:19: error: slice start out of bounds: start 3, length 2 +// :6421:27: error: slice end out of bounds: end 5, length 2 +// :6424:27: error: slice end out of bounds: end 6, length 2 +// :6427:27: error: slice end out of bounds: end 4, length 2 +// :6431:19: error: slice start out of bounds: start 3, length 2 +// :6435:19: error: slice start out of bounds: start 3, length 2 +// :6440:22: error: slice end out of bounds: end 2, length 1 +// :6443:22: error: slice end out of bounds: end 3, length 1 +// :6446:27: error: slice end out of bounds: end 2, length 1 +// :6449:27: error: slice end out of bounds: end 3, length 1 +// :6452:22: error: slice end out of bounds: end 2, length 1 +// :6455:22: error: slice end out of bounds: end 3, length 1 +// :6458:27: error: slice end out of bounds: end 3, length 1 +// :6461:27: error: slice end out of bounds: end 4, length 1 +// :6464:27: error: slice end out of bounds: end 2, length 1 +// :6467:19: error: slice start out of bounds: start 3, length 1 +// :6470:22: error: slice end out of bounds: end 2, length 1 +// :6473:22: error: slice end out of bounds: end 3, length 1 +// :6476:19: error: bounds out of order: start 3, end 1 +// :6480:19: error: slice start out of bounds: start 3, length 1 +// :6484:19: error: slice start out of bounds: start 3, length 1 +// :6487:27: error: slice end out of bounds: end 5, length 1 +// :6490:27: error: slice end out of bounds: end 6, length 1 +// :6493:27: error: slice end out of bounds: end 4, length 1 +// :6497:19: error: slice start out of bounds: start 3, length 1 +// :6501:19: error: slice start out of bounds: start 3, length 1 +// :6504:24: error: sentinel index always out of bounds +// :6507:22: error: slice end out of bounds: end 2(+1), length 1 +// :6510:22: error: slice end out of bounds: end 3(+1), length 1 +// :6513:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :6516:27: error: slice end out of bounds: end 2(+1), length 1 +// :6519:27: error: slice end out of bounds: end 3(+1), length 1 +// :6522:27: error: slice sentinel out of bounds: end 1(+1), length 1 +// :6525:24: error: sentinel index always out of bounds +// :6528:22: error: slice end out of bounds: end 2(+1), length 1 +// :6531:22: error: slice end out of bounds: end 3(+1), length 1 +// :6534:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :6538:19: error: slice sentinel always out of bounds: start 1, length 1 +// :6542:19: error: slice sentinel always out of bounds: start 1, length 1 +// :6545:27: error: slice end out of bounds: end 3(+1), length 1 +// :6548:27: error: slice end out of bounds: end 4(+1), length 1 +// :6551:27: error: slice end out of bounds: end 2(+1), length 1 +// :6555:19: error: slice sentinel always out of bounds: start 1, length 1 +// :6559:19: error: slice sentinel always out of bounds: start 1, length 1 +// :6562:24: error: sentinel index always out of bounds +// :6565:22: error: slice end out of bounds: end 2(+1), length 1 +// :6568:22: error: slice end out of bounds: end 3(+1), length 1 +// :6571:22: error: slice sentinel out of bounds: end 1(+1), length 1 +// :6575:19: error: slice start out of bounds: start 3, length 1 +// :6579:19: error: slice start out of bounds: start 3, length 1 +// :6582:27: error: slice end out of bounds: end 5(+1), length 1 +// :6585:27: error: slice end out of bounds: end 6(+1), length 1 +// :6588:27: error: slice end out of bounds: end 4(+1), length 1 +// :6592:19: error: slice start out of bounds: start 3, length 1 +// :6596:19: error: slice start out of bounds: start 3, length 1 +// :6601:22: error: slice end out of bounds: end 2, length 1 +// :6604:22: error: slice end out of bounds: end 3, length 1 +// :6607:27: error: slice end out of bounds: end 2, length 1 +// :6610:27: error: slice end out of bounds: end 3, length 1 +// :6613:19: error: slice start out of bounds: start 1, length 0 +// :6616:22: error: slice end out of bounds: end 2, length 1 +// :6619:22: error: slice end out of bounds: end 3, length 1 +// :6622:27: error: slice end out of bounds: end 3, length 1 +// :6625:27: error: slice end out of bounds: end 4, length 1 +// :6628:27: error: slice end out of bounds: end 2, length 1 +// :6631:19: error: slice start out of bounds: start 3, length 0 +// :6634:22: error: slice end out of bounds: end 2, length 1 +// :6637:22: error: slice end out of bounds: end 3, length 1 +// :6640:19: error: bounds out of order: start 3, end 1 +// :6644:19: error: slice start out of bounds: start 3, length 1 +// :6648:19: error: slice start out of bounds: start 3, length 1 +// :6651:27: error: slice end out of bounds: end 5, length 1 +// :6654:27: error: slice end out of bounds: end 6, length 1 +// :6657:27: error: slice end out of bounds: end 4, length 1 +// :6661:19: error: slice start out of bounds: start 3, length 1 +// :6665:19: error: slice start out of bounds: start 3, length 1 +// :6668:22: error: slice end out of bounds: end 2, length 0 +// :6671:22: error: slice end out of bounds: end 3, length 0 +// :6674:22: error: slice end out of bounds: end 1, length 0 +// :6677:27: error: slice end out of bounds: end 2, length 0 +// :6680:27: error: slice end out of bounds: end 3, length 0 +// :6683:27: error: slice end out of bounds: end 1, length 0 +// :6686:19: error: slice start out of bounds: start 1, length 0 +// :6689:22: error: slice end out of bounds: end 2, length 0 +// :6692:22: error: slice end out of bounds: end 3, length 0 +// :6695:22: error: slice end out of bounds: end 1, length 0 +// :6699:19: error: slice start out of bounds: start 1, length 0 +// :6703:19: error: slice start out of bounds: start 1, length 0 +// :6706:27: error: slice end out of bounds: end 3, length 0 +// :6709:27: error: slice end out of bounds: end 4, length 0 +// :6712:27: error: slice end out of bounds: end 2, length 0 +// :6716:19: error: slice start out of bounds: start 1, length 0 +// :6720:19: error: slice start out of bounds: start 1, length 0 +// :6723:19: error: slice start out of bounds: start 3, length 0 +// :6726:22: error: slice end out of bounds: end 2, length 0 +// :6729:22: error: slice end out of bounds: end 3, length 0 +// :6732:22: error: slice end out of bounds: end 1, length 0 +// :6736:19: error: slice start out of bounds: start 3, length 0 +// :6740:19: error: slice start out of bounds: start 3, length 0 +// :6743:27: error: slice end out of bounds: end 5, length 0 +// :6746:27: error: slice end out of bounds: end 6, length 0 +// :6749:27: error: slice end out of bounds: end 4, length 0 +// :6753:19: error: slice start out of bounds: start 3, length 0 +// :6757:19: error: slice start out of bounds: start 3, length 0 +// :6790:19: error: slice start out of bounds: start 3, length 2 +// :6794:19: error: slice start out of bounds: start 3, length 2 +// :6807:19: error: slice start out of bounds: start 3, length 2 +// :6811:19: error: slice start out of bounds: start 3, length 2 +// :6869:19: error: slice start out of bounds: start 3, length 2 +// :6873:19: error: slice start out of bounds: start 3, length 2 +// :6886:19: error: slice start out of bounds: start 3, length 2 +// :6890:19: error: slice start out of bounds: start 3, length 2 +// :6923:19: error: slice start out of bounds: start 3, length 2 +// :6927:19: error: slice start out of bounds: start 3, length 2 +// :6940:19: error: slice start out of bounds: start 3, length 2 +// :6944:19: error: slice start out of bounds: start 3, length 2 +// :7002:19: error: slice start out of bounds: start 3, length 1 +// :7006:19: error: slice start out of bounds: start 3, length 1 +// :7019:19: error: slice start out of bounds: start 3, length 1 +// :7023:19: error: slice start out of bounds: start 3, length 1 +// :7101:19: error: slice sentinel always out of bounds: start 3, length 3 +// :7105:19: error: slice sentinel always out of bounds: start 3, length 3 +// :7118:19: error: slice sentinel always out of bounds: start 3, length 3 +// :7122:19: error: slice sentinel always out of bounds: start 3, length 3 +// :7203:19: error: slice start out of bounds: start 3, length 2 +// :7207:19: error: slice start out of bounds: start 3, length 2 +// :7220:19: error: slice start out of bounds: start 3, length 2 +// :7224:19: error: slice start out of bounds: start 3, length 2 +// :7269:19: error: slice start out of bounds: start 3, length 1 +// :7273:19: error: slice start out of bounds: start 3, length 1 +// :7286:19: error: slice start out of bounds: start 3, length 1 +// :7290:19: error: slice start out of bounds: start 3, length 1 +// :7327:19: error: slice sentinel always out of bounds: start 1, length 1 +// :7331:19: error: slice sentinel always out of bounds: start 1, length 1 +// :7344:19: error: slice sentinel always out of bounds: start 1, length 1 +// :7348:19: error: slice sentinel always out of bounds: start 1, length 1 +// :7364:19: error: slice start out of bounds: start 3, length 1 +// :7368:19: error: slice start out of bounds: start 3, length 1 +// :7381:19: error: slice start out of bounds: start 3, length 1 +// :7385:19: error: slice start out of bounds: start 3, length 1 +// :7433:19: error: slice start out of bounds: start 3, length 1 +// :7437:19: error: slice start out of bounds: start 3, length 1 +// :7450:19: error: slice start out of bounds: start 3, length 1 +// :7454:19: error: slice start out of bounds: start 3, length 1 +// :7491:19: error: slice start out of bounds: start 1, length 0 +// :7495:19: error: slice start out of bounds: start 1, length 0 +// :7508:19: error: slice start out of bounds: start 1, length 0 +// :7512:19: error: slice start out of bounds: start 1, length 0 +// :7528:19: error: slice start out of bounds: start 3, length 0 +// :7532:19: error: slice start out of bounds: start 3, length 0 +// :7545:19: error: slice start out of bounds: start 3, length 0 +// :7549:19: error: slice start out of bounds: start 3, length 0 +// :7554:19: error: bounds out of order: start 3, end 2 +// :7557:19: error: bounds out of order: start 3, end 1 +// :7560:24: error: sentinel index always out of bounds +// :7563:24: error: sentinel index always out of bounds +// :7566:24: error: sentinel index always out of bounds +// :7569:19: error: bounds out of order: start 3, end 2 +// :7572:19: error: bounds out of order: start 3, end 1 +// :7577:19: error: bounds out of order: start 3, end 2 +// :7580:19: error: bounds out of order: start 3, end 1 +// :7583:19: error: bounds out of order: start 3, end 2 +// :7586:19: error: bounds out of order: start 3, end 1 +// :7591:19: error: bounds out of order: start 3, end 2 +// :7594:19: error: bounds out of order: start 3, end 1 +// :7597:24: error: sentinel index always out of bounds +// :7600:24: error: sentinel index always out of bounds +// :7603:24: error: sentinel index always out of bounds +// :7606:19: error: bounds out of order: start 3, end 2 +// :7609:19: error: bounds out of order: start 3, end 1 +// :7614:19: error: bounds out of order: start 3, end 2 +// :7617:19: error: bounds out of order: start 3, end 1 +// :7620:19: error: bounds out of order: start 3, end 2 +// :7623:19: error: bounds out of order: start 3, end 1 +// :7628:20: error: bounds out of order: start 3, end 2 +// :7631:20: error: bounds out of order: start 3, end 1 +// :7634:25: error: sentinel index always out of bounds +// :7637:25: error: sentinel index always out of bounds +// :7640:25: error: sentinel index always out of bounds +// :7643:20: error: bounds out of order: start 3, end 2 +// :7646:20: error: bounds out of order: start 3, end 1 +// :7651:20: error: bounds out of order: start 3, end 2 +// :7654:20: error: bounds out of order: start 3, end 1 +// :7657:20: error: bounds out of order: start 3, end 2 +// :7660:20: error: bounds out of order: start 3, end 1 +// :7693:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7697:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7710:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7714:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7766:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7770:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7783:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7787:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7820:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7824:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7837:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7841:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7893:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7897:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7910:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7914:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :7986:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :7990:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8003:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8007:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8079:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8083:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8096:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8100:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :8145:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8149:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8162:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8166:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8200:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8204:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8217:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8221:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8237:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8241:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8254:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8258:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8303:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8307:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8320:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8324:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8358:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8362:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8375:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8379:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :8395:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8399:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8412:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8416:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :8421:20: error: bounds out of order: start 3, end 2 +// :8424:20: error: bounds out of order: start 3, end 1 +// :8427:20: error: bounds out of order: start 3, end 2 +// :8430:20: error: bounds out of order: start 3, end 1 +// :8435:20: error: bounds out of order: start 3, end 2 +// :8438:20: error: bounds out of order: start 3, end 1 +// :8441:20: error: bounds out of order: start 3, end 2 +// :8444:20: error: bounds out of order: start 3, end 1 +// :8449:20: error: bounds out of order: start 3, end 2 +// :8452:20: error: bounds out of order: start 3, end 1 +// :8455:20: error: bounds out of order: start 3, end 2 +// :8458:20: error: bounds out of order: start 3, end 1 +// :8463:20: error: bounds out of order: start 3, end 2 +// :8466:20: error: bounds out of order: start 3, end 1 +// :8469:20: error: bounds out of order: start 3, end 2 +// :8472:20: error: bounds out of order: start 3, end 1 +// :8477:20: error: bounds out of order: start 3, end 2 +// :8480:20: error: bounds out of order: start 3, end 1 +// :8483:20: error: bounds out of order: start 3, end 2 +// :8486:20: error: bounds out of order: start 3, end 1 +// :8491:20: error: bounds out of order: start 3, end 2 +// :8494:20: error: bounds out of order: start 3, end 1 +// :8497:20: error: bounds out of order: start 3, end 2 +// :8500:20: error: bounds out of order: start 3, end 1 +// :8517:9: error: slice of null pointer +// :8521:9: error: slice of null pointer +// :8534:19: error: slice of null pointer +// :8538:19: error: slice of null pointer +// :8554:9: error: slice of null pointer +// :8558:9: error: slice of null pointer +// :8571:19: error: slice of null pointer +// :8575:19: error: slice of null pointer +// :8591:9: error: slice of null pointer +// :8595:9: error: slice of null pointer +// :8608:19: error: slice of null pointer +// :8612:19: error: slice of null pointer +// :8628:9: error: slice of null pointer +// :8632:9: error: slice of null pointer +// :8645:19: error: slice of null pointer +// :8649:19: error: slice of null pointer +// :8665:9: error: slice of null pointer +// :8669:9: error: slice of null pointer +// :8682:19: error: slice of null pointer +// :8686:19: error: slice of null pointer +// :8702:9: error: slice of null pointer +// :8706:9: error: slice of null pointer +// :8719:19: error: slice of null pointer +// :8723:19: error: slice of null pointer +// :8740:9: error: slice of null pointer +// :8744:9: error: slice of null pointer +// :8757:19: error: slice of null pointer +// :8761:19: error: slice of null pointer +// :8777:9: error: slice of null pointer +// :8781:9: error: slice of null pointer +// :8794:19: error: slice of null pointer +// :8798:19: error: slice of null pointer +// :8814:9: error: slice of null pointer +// :8818:9: error: slice of null pointer +// :8831:19: error: slice of null pointer +// :8835:19: error: slice of null pointer +// :8851:9: error: slice of null pointer +// :8855:9: error: slice of null pointer +// :8868:19: error: slice of null pointer +// :8872:19: error: slice of null pointer +// :8888:9: error: slice of null pointer +// :8892:9: error: slice of null pointer +// :8905:19: error: slice of null pointer +// :8909:19: error: slice of null pointer +// :8925:9: error: slice of null pointer +// :8929:9: error: slice of null pointer +// :8942:19: error: slice of null pointer +// :8946:19: error: slice of null pointer +// :8963:9: error: slice of null pointer +// :8967:9: error: slice of null pointer +// :8980:19: error: slice of null pointer +// :8984:19: error: slice of null pointer +// :9000:9: error: slice of null pointer +// :9004:9: error: slice of null pointer +// :9017:19: error: slice of null pointer +// :9021:19: error: slice of null pointer +// :9037:9: error: slice of null pointer +// :9041:9: error: slice of null pointer +// :9054:19: error: slice of null pointer +// :9058:19: error: slice of null pointer +// :9074:9: error: slice of null pointer +// :9078:9: error: slice of null pointer +// :9091:19: error: slice of null pointer +// :9095:19: error: slice of null pointer +// :9111:9: error: slice of null pointer +// :9115:9: error: slice of null pointer +// :9128:19: error: slice of null pointer +// :9132:19: error: slice of null pointer +// :9148:9: error: slice of null pointer +// :9152:9: error: slice of null pointer +// :9165:19: error: slice of null pointer +// :9169:19: error: slice of null pointer +// :9173:20: error: bounds out of order: start 3, end 2 +// :9176:20: error: bounds out of order: start 3, end 1 +// :9179:20: error: bounds out of order: start 3, end 2 +// :9182:20: error: bounds out of order: start 3, end 1 +// :9186:20: error: bounds out of order: start 3, end 2 +// :9189:20: error: bounds out of order: start 3, end 1 +// :9192:20: error: bounds out of order: start 3, end 2 +// :9195:20: error: bounds out of order: start 3, end 1 +// :9199:20: error: bounds out of order: start 3, end 2 +// :9202:20: error: bounds out of order: start 3, end 1 +// :9205:20: error: bounds out of order: start 3, end 2 +// :9208:20: error: bounds out of order: start 3, end 1 +// :9241:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9245:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9258:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9262:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9314:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9318:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9331:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9335:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :9407:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :9411:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :9424:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :9428:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :9473:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9477:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9490:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9494:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9528:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :9532:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :9545:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :9549:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :9565:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9569:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9582:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9586:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :9591:20: error: bounds out of order: start 3, end 2 +// :9594:20: error: bounds out of order: start 3, end 1 +// :9597:20: error: bounds out of order: start 3, end 2 +// :9600:20: error: bounds out of order: start 3, end 1 +// :9605:20: error: bounds out of order: start 3, end 2 +// :9608:20: error: bounds out of order: start 3, end 1 +// :9611:20: error: bounds out of order: start 3, end 2 +// :9614:20: error: bounds out of order: start 3, end 1 +// :9619:20: error: bounds out of order: start 3, end 2 +// :9622:20: error: bounds out of order: start 3, end 1 +// :9625:20: error: bounds out of order: start 3, end 2 +// :9628:20: error: bounds out of order: start 3, end 1 +// :9661:20: error: slice start out of bounds: start 3, length 2 +// :9665:20: error: slice start out of bounds: start 3, length 2 +// :9678:20: error: slice start out of bounds: start 3, length 2 +// :9682:20: error: slice start out of bounds: start 3, length 2 +// :9731:20: error: slice start out of bounds: start 3, length 2 +// :9735:20: error: slice start out of bounds: start 3, length 2 +// :9748:20: error: slice start out of bounds: start 3, length 2 +// :9752:20: error: slice start out of bounds: start 3, length 2 +// :9785:20: error: slice start out of bounds: start 3, length 2 +// :9789:20: error: slice start out of bounds: start 3, length 2 +// :9802:20: error: slice start out of bounds: start 3, length 2 +// :9806:20: error: slice start out of bounds: start 3, length 2 +// :9864:20: error: slice start out of bounds: start 3, length 1 +// :9868:20: error: slice start out of bounds: start 3, length 1 +// :9881:20: error: slice start out of bounds: start 3, length 1 +// :9885:20: error: slice start out of bounds: start 3, length 1 +// :9942:20: error: slice sentinel always out of bounds: start 3, length 3 +// :9946:20: error: slice sentinel always out of bounds: start 3, length 3 +// :9959:20: error: slice sentinel always out of bounds: start 3, length 3 +// :9963:20: error: slice sentinel always out of bounds: start 3, length 3 +// :10035:20: error: slice start out of bounds: start 3, length 2 +// :10039:20: error: slice start out of bounds: start 3, length 2 +// :10052:20: error: slice start out of bounds: start 3, length 2 +// :10056:20: error: slice start out of bounds: start 3, length 2 +// :10101:20: error: slice start out of bounds: start 3, length 1 +// :10105:20: error: slice start out of bounds: start 3, length 1 +// :10118:20: error: slice start out of bounds: start 3, length 1 +// :10122:20: error: slice start out of bounds: start 3, length 1 +// :10159:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10163:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10176:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10180:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10196:20: error: slice start out of bounds: start 3, length 1 +// :10200:20: error: slice start out of bounds: start 3, length 1 +// :10213:20: error: slice start out of bounds: start 3, length 1 +// :10217:20: error: slice start out of bounds: start 3, length 1 +// :10265:20: error: slice start out of bounds: start 3, length 1 +// :10269:20: error: slice start out of bounds: start 3, length 1 +// :10282:20: error: slice start out of bounds: start 3, length 1 +// :10286:20: error: slice start out of bounds: start 3, length 1 +// :10323:20: error: slice start out of bounds: start 1, length 0 +// :10327:20: error: slice start out of bounds: start 1, length 0 +// :10340:20: error: slice start out of bounds: start 1, length 0 +// :10344:20: error: slice start out of bounds: start 1, length 0 +// :10360:20: error: slice start out of bounds: start 3, length 0 +// :10364:20: error: slice start out of bounds: start 3, length 0 +// :10377:20: error: slice start out of bounds: start 3, length 0 +// :10381:20: error: slice start out of bounds: start 3, length 0 +// :10386:23: error: slice end out of bounds: end 3, length 2 +// :10389:28: error: slice end out of bounds: end 3, length 2 +// :10392:23: error: slice end out of bounds: end 3, length 2 +// :10395:28: error: slice end out of bounds: end 3, length 2 +// :10398:28: error: slice end out of bounds: end 4, length 2 +// :10401:20: error: slice start out of bounds: start 3, length 2 +// :10404:20: error: bounds out of order: start 3, end 2 +// :10407:23: error: slice end out of bounds: end 3, length 2 +// :10410:20: error: bounds out of order: start 3, end 1 +// :10414:20: error: slice start out of bounds: start 3, length 2 +// :10418:20: error: slice start out of bounds: start 3, length 2 +// :10421:28: error: slice end out of bounds: end 5, length 2 +// :10424:28: error: slice end out of bounds: end 6, length 2 +// :10427:28: error: slice end out of bounds: end 4, length 2 +// :10431:20: error: slice start out of bounds: start 3, length 2 +// :10435:20: error: slice start out of bounds: start 3, length 2 +// :10438:25: error: sentinel index always out of bounds +// :10441:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :10444:23: error: slice end out of bounds: end 3(+1), length 2 +// :10447:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :10450:28: error: slice end out of bounds: end 3(+1), length 2 +// :10453:25: error: sentinel index always out of bounds +// :10456:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :10459:23: error: slice end out of bounds: end 3(+1), length 2 +// :10462:28: error: slice end out of bounds: end 3(+1), length 2 +// :10465:28: error: slice end out of bounds: end 4(+1), length 2 +// :10468:28: error: slice sentinel out of bounds: end 2(+1), length 2 +// :10471:25: error: sentinel index always out of bounds +// :10474:23: error: slice sentinel out of bounds: end 2(+1), length 2 +// :10477:23: error: slice end out of bounds: end 3(+1), length 2 +// :10480:20: error: bounds out of order: start 3, end 1 +// :10484:20: error: slice start out of bounds: start 3, length 2 +// :10488:20: error: slice start out of bounds: start 3, length 2 +// :10491:28: error: slice end out of bounds: end 5(+1), length 2 +// :10494:28: error: slice end out of bounds: end 6(+1), length 2 +// :10497:28: error: slice end out of bounds: end 4(+1), length 2 +// :10501:20: error: slice start out of bounds: start 3, length 2 +// :10505:20: error: slice start out of bounds: start 3, length 2 +// :10510:23: error: slice end out of bounds: end 3, length 2 +// :10513:28: error: slice end out of bounds: end 3, length 2 +// :10516:23: error: slice end out of bounds: end 3, length 2 +// :10519:28: error: slice end out of bounds: end 3, length 2 +// :10522:28: error: slice end out of bounds: end 4, length 2 +// :10525:20: error: slice start out of bounds: start 3, length 1 +// :10528:20: error: bounds out of order: start 3, end 2 +// :10531:23: error: slice end out of bounds: end 3, length 2 +// :10534:20: error: bounds out of order: start 3, end 1 +// :10538:20: error: slice start out of bounds: start 3, length 2 +// :10542:20: error: slice start out of bounds: start 3, length 2 +// :10545:28: error: slice end out of bounds: end 5, length 2 +// :10548:28: error: slice end out of bounds: end 6, length 2 +// :10551:28: error: slice end out of bounds: end 4, length 2 +// :10555:20: error: slice start out of bounds: start 3, length 2 +// :10559:20: error: slice start out of bounds: start 3, length 2 +// :10562:23: error: slice end out of bounds: end 2, length 1 +// :10565:23: error: slice end out of bounds: end 3, length 1 +// :10568:28: error: slice end out of bounds: end 2, length 1 +// :10571:28: error: slice end out of bounds: end 3, length 1 +// :10574:23: error: slice end out of bounds: end 2, length 1 +// :10577:23: error: slice end out of bounds: end 3, length 1 +// :10580:28: error: slice end out of bounds: end 3, length 1 +// :10583:28: error: slice end out of bounds: end 4, length 1 +// :10586:28: error: slice end out of bounds: end 2, length 1 +// :10589:20: error: slice start out of bounds: start 3, length 1 +// :10592:23: error: slice end out of bounds: end 2, length 1 +// :10595:23: error: slice end out of bounds: end 3, length 1 +// :10598:20: error: bounds out of order: start 3, end 1 +// :10602:20: error: slice start out of bounds: start 3, length 1 +// :10606:20: error: slice start out of bounds: start 3, length 1 +// :10609:28: error: slice end out of bounds: end 5, length 1 +// :10612:28: error: slice end out of bounds: end 6, length 1 +// :10615:28: error: slice end out of bounds: end 4, length 1 +// :10619:20: error: slice start out of bounds: start 3, length 1 +// :10623:20: error: slice start out of bounds: start 3, length 1 +// :10628:28: error: slice end out of bounds: end 4, length 3 +// :10631:20: error: bounds out of order: start 3, end 2 +// :10634:20: error: bounds out of order: start 3, end 1 +// :10637:28: error: slice end out of bounds: end 5, length 3 +// :10640:28: error: slice end out of bounds: end 6, length 3 +// :10643:28: error: slice end out of bounds: end 4, length 3 +// :10646:25: error: sentinel index always out of bounds +// :10649:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :10652:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :10655:25: error: sentinel index always out of bounds +// :10658:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :10661:28: error: slice sentinel out of bounds: end 3(+1), length 3 +// :10664:28: error: slice end out of bounds: end 4(+1), length 3 +// :10667:25: error: sentinel index always out of bounds +// :10670:20: error: bounds out of order: start 3, end 2 +// :10673:23: error: slice sentinel out of bounds: end 3(+1), length 3 +// :10676:20: error: bounds out of order: start 3, end 1 +// :10680:20: error: slice sentinel always out of bounds: start 3, length 3 +// :10684:20: error: slice sentinel always out of bounds: start 3, length 3 +// :10687:28: error: slice end out of bounds: end 5(+1), length 3 +// :10690:28: error: slice end out of bounds: end 6(+1), length 3 +// :10693:28: error: slice end out of bounds: end 4(+1), length 3 +// :10697:20: error: slice sentinel always out of bounds: start 3, length 3 +// :10701:20: error: slice sentinel always out of bounds: start 3, length 3 +// :10706:28: error: slice end out of bounds: end 4, length 3 +// :10709:20: error: slice start out of bounds: start 3, length 2 +// :10712:20: error: bounds out of order: start 3, end 2 +// :10715:20: error: bounds out of order: start 3, end 1 +// :10718:28: error: slice end out of bounds: end 5, length 3 +// :10721:28: error: slice end out of bounds: end 6, length 3 +// :10724:28: error: slice end out of bounds: end 4, length 3 +// :10727:23: error: slice end out of bounds: end 3, length 2 +// :10730:28: error: slice end out of bounds: end 3, length 2 +// :10733:23: error: slice end out of bounds: end 3, length 2 +// :10736:28: error: slice end out of bounds: end 3, length 2 +// :10739:28: error: slice end out of bounds: end 4, length 2 +// :10742:20: error: slice start out of bounds: start 3, length 2 +// :10745:20: error: bounds out of order: start 3, end 2 +// :10748:23: error: slice end out of bounds: end 3, length 2 +// :10751:20: error: bounds out of order: start 3, end 1 +// :10755:20: error: slice start out of bounds: start 3, length 2 +// :10759:20: error: slice start out of bounds: start 3, length 2 +// :10762:28: error: slice end out of bounds: end 5, length 2 +// :10765:28: error: slice end out of bounds: end 6, length 2 +// :10768:28: error: slice end out of bounds: end 4, length 2 +// :10772:20: error: slice start out of bounds: start 3, length 2 +// :10776:20: error: slice start out of bounds: start 3, length 2 +// :10781:23: error: slice end out of bounds: end 2, length 1 +// :10784:23: error: slice end out of bounds: end 3, length 1 +// :10787:28: error: slice end out of bounds: end 2, length 1 +// :10790:28: error: slice end out of bounds: end 3, length 1 +// :10793:23: error: slice end out of bounds: end 2, length 1 +// :10796:23: error: slice end out of bounds: end 3, length 1 +// :10799:28: error: slice end out of bounds: end 3, length 1 +// :10802:28: error: slice end out of bounds: end 4, length 1 +// :10805:28: error: slice end out of bounds: end 2, length 1 +// :10808:20: error: slice start out of bounds: start 3, length 1 +// :10811:23: error: slice end out of bounds: end 2, length 1 +// :10814:23: error: slice end out of bounds: end 3, length 1 +// :10817:20: error: bounds out of order: start 3, end 1 +// :10821:20: error: slice start out of bounds: start 3, length 1 +// :10825:20: error: slice start out of bounds: start 3, length 1 +// :10828:28: error: slice end out of bounds: end 5, length 1 +// :10831:28: error: slice end out of bounds: end 6, length 1 +// :10834:28: error: slice end out of bounds: end 4, length 1 +// :10838:20: error: slice start out of bounds: start 3, length 1 +// :10842:20: error: slice start out of bounds: start 3, length 1 +// :10845:25: error: sentinel index always out of bounds +// :10848:23: error: slice end out of bounds: end 2(+1), length 1 +// :10851:23: error: slice end out of bounds: end 3(+1), length 1 +// :10854:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10857:28: error: slice end out of bounds: end 2(+1), length 1 +// :10860:28: error: slice end out of bounds: end 3(+1), length 1 +// :10863:28: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10866:25: error: sentinel index always out of bounds +// :10869:23: error: slice end out of bounds: end 2(+1), length 1 +// :10872:23: error: slice end out of bounds: end 3(+1), length 1 +// :10875:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10879:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10883:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10886:28: error: slice end out of bounds: end 3(+1), length 1 +// :10889:28: error: slice end out of bounds: end 4(+1), length 1 +// :10892:28: error: slice end out of bounds: end 2(+1), length 1 +// :10896:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10900:20: error: slice sentinel always out of bounds: start 1, length 1 +// :10903:25: error: sentinel index always out of bounds +// :10906:23: error: slice end out of bounds: end 2(+1), length 1 +// :10909:23: error: slice end out of bounds: end 3(+1), length 1 +// :10912:23: error: slice sentinel out of bounds: end 1(+1), length 1 +// :10916:20: error: slice start out of bounds: start 3, length 1 +// :10920:20: error: slice start out of bounds: start 3, length 1 +// :10923:28: error: slice end out of bounds: end 5(+1), length 1 +// :10926:28: error: slice end out of bounds: end 6(+1), length 1 +// :10929:28: error: slice end out of bounds: end 4(+1), length 1 +// :10933:20: error: slice start out of bounds: start 3, length 1 +// :10937:20: error: slice start out of bounds: start 3, length 1 +// :10942:23: error: slice end out of bounds: end 2, length 1 +// :10945:23: error: slice end out of bounds: end 3, length 1 +// :10948:28: error: slice end out of bounds: end 2, length 1 +// :10951:28: error: slice end out of bounds: end 3, length 1 +// :10954:20: error: slice start out of bounds: start 1, length 0 +// :10957:23: error: slice end out of bounds: end 2, length 1 +// :10960:23: error: slice end out of bounds: end 3, length 1 +// :10963:28: error: slice end out of bounds: end 3, length 1 +// :10966:28: error: slice end out of bounds: end 4, length 1 +// :10969:28: error: slice end out of bounds: end 2, length 1 +// :10972:20: error: slice start out of bounds: start 3, length 0 +// :10975:23: error: slice end out of bounds: end 2, length 1 +// :10978:23: error: slice end out of bounds: end 3, length 1 +// :10981:20: error: bounds out of order: start 3, end 1 +// :10985:20: error: slice start out of bounds: start 3, length 1 +// :10989:20: error: slice start out of bounds: start 3, length 1 +// :10992:28: error: slice end out of bounds: end 5, length 1 +// :10995:28: error: slice end out of bounds: end 6, length 1 +// :10998:28: error: slice end out of bounds: end 4, length 1 +// :11002:20: error: slice start out of bounds: start 3, length 1 +// :11006:20: error: slice start out of bounds: start 3, length 1 +// :11009:23: error: slice end out of bounds: end 2, length 0 +// :11012:23: error: slice end out of bounds: end 3, length 0 +// :11015:23: error: slice end out of bounds: end 1, length 0 +// :11018:28: error: slice end out of bounds: end 2, length 0 +// :11021:28: error: slice end out of bounds: end 3, length 0 +// :11024:28: error: slice end out of bounds: end 1, length 0 +// :11027:20: error: slice start out of bounds: start 1, length 0 +// :11030:23: error: slice end out of bounds: end 2, length 0 +// :11033:23: error: slice end out of bounds: end 3, length 0 +// :11036:23: error: slice end out of bounds: end 1, length 0 +// :11040:20: error: slice start out of bounds: start 1, length 0 +// :11044:20: error: slice start out of bounds: start 1, length 0 +// :11047:28: error: slice end out of bounds: end 3, length 0 +// :11050:28: error: slice end out of bounds: end 4, length 0 +// :11053:28: error: slice end out of bounds: end 2, length 0 +// :11057:20: error: slice start out of bounds: start 1, length 0 +// :11061:20: error: slice start out of bounds: start 1, length 0 +// :11064:20: error: slice start out of bounds: start 3, length 0 +// :11067:23: error: slice end out of bounds: end 2, length 0 +// :11070:23: error: slice end out of bounds: end 3, length 0 +// :11073:23: error: slice end out of bounds: end 1, length 0 +// :11077:20: error: slice start out of bounds: start 3, length 0 +// :11081:20: error: slice start out of bounds: start 3, length 0 +// :11084:28: error: slice end out of bounds: end 5, length 0 +// :11087:28: error: slice end out of bounds: end 6, length 0 +// :11090:28: error: slice end out of bounds: end 4, length 0 +// :11094:20: error: slice start out of bounds: start 3, length 0 +// :11098:20: error: slice start out of bounds: start 3, length 0 +// :11131:20: error: slice start out of bounds: start 3, length 2 +// :11135:20: error: slice start out of bounds: start 3, length 2 +// :11148:20: error: slice start out of bounds: start 3, length 2 +// :11152:20: error: slice start out of bounds: start 3, length 2 +// :11201:20: error: slice start out of bounds: start 3, length 2 +// :11205:20: error: slice start out of bounds: start 3, length 2 +// :11218:20: error: slice start out of bounds: start 3, length 2 +// :11222:20: error: slice start out of bounds: start 3, length 2 +// :11255:20: error: slice start out of bounds: start 3, length 2 +// :11259:20: error: slice start out of bounds: start 3, length 2 +// :11272:20: error: slice start out of bounds: start 3, length 2 +// :11276:20: error: slice start out of bounds: start 3, length 2 +// :11334:20: error: slice start out of bounds: start 3, length 1 +// :11338:20: error: slice start out of bounds: start 3, length 1 +// :11351:20: error: slice start out of bounds: start 3, length 1 +// :11355:20: error: slice start out of bounds: start 3, length 1 +// :11412:20: error: slice sentinel always out of bounds: start 3, length 3 +// :11416:20: error: slice sentinel always out of bounds: start 3, length 3 +// :11429:20: error: slice sentinel always out of bounds: start 3, length 3 +// :11433:20: error: slice sentinel always out of bounds: start 3, length 3 +// :11505:20: error: slice start out of bounds: start 3, length 2 +// :11509:20: error: slice start out of bounds: start 3, length 2 +// :11522:20: error: slice start out of bounds: start 3, length 2 +// :11526:20: error: slice start out of bounds: start 3, length 2 +// :11571:20: error: slice start out of bounds: start 3, length 1 +// :11575:20: error: slice start out of bounds: start 3, length 1 +// :11588:20: error: slice start out of bounds: start 3, length 1 +// :11592:20: error: slice start out of bounds: start 3, length 1 +// :11629:20: error: slice sentinel always out of bounds: start 1, length 1 +// :11633:20: error: slice sentinel always out of bounds: start 1, length 1 +// :11646:20: error: slice sentinel always out of bounds: start 1, length 1 +// :11650:20: error: slice sentinel always out of bounds: start 1, length 1 +// :11666:20: error: slice start out of bounds: start 3, length 1 +// :11670:20: error: slice start out of bounds: start 3, length 1 +// :11683:20: error: slice start out of bounds: start 3, length 1 +// :11687:20: error: slice start out of bounds: start 3, length 1 +// :11735:20: error: slice start out of bounds: start 3, length 1 +// :11739:20: error: slice start out of bounds: start 3, length 1 +// :11752:20: error: slice start out of bounds: start 3, length 1 +// :11756:20: error: slice start out of bounds: start 3, length 1 +// :11793:20: error: slice start out of bounds: start 1, length 0 +// :11797:20: error: slice start out of bounds: start 1, length 0 +// :11810:20: error: slice start out of bounds: start 1, length 0 +// :11814:20: error: slice start out of bounds: start 1, length 0 +// :11830:20: error: slice start out of bounds: start 3, length 0 +// :11834:20: error: slice start out of bounds: start 3, length 0 +// :11847:20: error: slice start out of bounds: start 3, length 0 +// :11851:20: error: slice start out of bounds: start 3, length 0 +// :11856:20: error: bounds out of order: start 3, end 2 +// :11859:20: error: bounds out of order: start 3, end 1 +// :11862:25: error: sentinel index always out of bounds +// :11865:25: error: sentinel index always out of bounds +// :11868:25: error: sentinel index always out of bounds +// :11871:20: error: bounds out of order: start 3, end 2 +// :11874:20: error: bounds out of order: start 3, end 1 +// :11879:20: error: bounds out of order: start 3, end 2 +// :11882:20: error: bounds out of order: start 3, end 1 +// :11885:20: error: bounds out of order: start 3, end 2 +// :11888:20: error: bounds out of order: start 3, end 1 +// :11893:20: error: bounds out of order: start 3, end 2 +// :11896:20: error: bounds out of order: start 3, end 1 +// :11899:25: error: sentinel index always out of bounds +// :11902:25: error: sentinel index always out of bounds +// :11905:25: error: sentinel index always out of bounds +// :11908:20: error: bounds out of order: start 3, end 2 +// :11911:20: error: bounds out of order: start 3, end 1 +// :11916:20: error: bounds out of order: start 3, end 2 +// :11919:20: error: bounds out of order: start 3, end 1 +// :11922:20: error: bounds out of order: start 3, end 2 +// :11925:20: error: bounds out of order: start 3, end 1 +// :11930:20: error: bounds out of order: start 3, end 2 +// :11933:20: error: bounds out of order: start 3, end 1 +// :11936:25: error: sentinel index always out of bounds +// :11939:25: error: sentinel index always out of bounds +// :11942:25: error: sentinel index always out of bounds +// :11945:20: error: bounds out of order: start 3, end 2 +// :11948:20: error: bounds out of order: start 3, end 1 +// :11953:20: error: bounds out of order: start 3, end 2 +// :11956:20: error: bounds out of order: start 3, end 1 +// :11959:20: error: bounds out of order: start 3, end 2 +// :11962:20: error: bounds out of order: start 3, end 1 +// :11995:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :11999:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12012:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12016:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12059:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12063:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12076:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12080:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12113:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12117:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12130:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12134:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12186:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12190:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12203:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12207:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :12258:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12262:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12275:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12279:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12342:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12346:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12359:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12363:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :12408:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12412:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12425:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12429:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12463:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12467:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12480:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12484:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12500:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12504:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12517:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12521:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12566:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12570:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12583:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12587:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12621:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12625:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12638:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12642:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :12658:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12662:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12675:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12679:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :12684:20: error: bounds out of order: start 3, end 2 +// :12687:20: error: bounds out of order: start 3, end 1 +// :12690:20: error: bounds out of order: start 3, end 2 +// :12693:20: error: bounds out of order: start 3, end 1 +// :12698:20: error: bounds out of order: start 3, end 2 +// :12701:20: error: bounds out of order: start 3, end 1 +// :12704:20: error: bounds out of order: start 3, end 2 +// :12707:20: error: bounds out of order: start 3, end 1 +// :12712:20: error: bounds out of order: start 3, end 2 +// :12715:20: error: bounds out of order: start 3, end 1 +// :12718:20: error: bounds out of order: start 3, end 2 +// :12721:20: error: bounds out of order: start 3, end 1 +// :12726:20: error: bounds out of order: start 3, end 2 +// :12729:20: error: bounds out of order: start 3, end 1 +// :12732:20: error: bounds out of order: start 3, end 2 +// :12735:20: error: bounds out of order: start 3, end 1 +// :12740:20: error: bounds out of order: start 3, end 2 +// :12743:20: error: bounds out of order: start 3, end 1 +// :12746:20: error: bounds out of order: start 3, end 2 +// :12749:20: error: bounds out of order: start 3, end 1 +// :12754:20: error: bounds out of order: start 3, end 2 +// :12757:20: error: bounds out of order: start 3, end 1 +// :12760:20: error: bounds out of order: start 3, end 2 +// :12763:20: error: bounds out of order: start 3, end 1 +// :12780:9: error: slice of null pointer +// :12784:9: error: slice of null pointer +// :12797:19: error: slice of null pointer +// :12801:19: error: slice of null pointer +// :12817:9: error: slice of null pointer +// :12821:9: error: slice of null pointer +// :12834:19: error: slice of null pointer +// :12838:19: error: slice of null pointer +// :12854:9: error: slice of null pointer +// :12858:9: error: slice of null pointer +// :12871:19: error: slice of null pointer +// :12875:19: error: slice of null pointer +// :12891:9: error: slice of null pointer +// :12895:9: error: slice of null pointer +// :12908:19: error: slice of null pointer +// :12912:19: error: slice of null pointer +// :12928:9: error: slice of null pointer +// :12932:9: error: slice of null pointer +// :12945:19: error: slice of null pointer +// :12949:19: error: slice of null pointer +// :12965:9: error: slice of null pointer +// :12969:9: error: slice of null pointer +// :12982:19: error: slice of null pointer +// :12986:19: error: slice of null pointer +// :13003:9: error: slice of null pointer +// :13007:9: error: slice of null pointer +// :13020:19: error: slice of null pointer +// :13024:19: error: slice of null pointer +// :13040:9: error: slice of null pointer +// :13044:9: error: slice of null pointer +// :13057:19: error: slice of null pointer +// :13061:19: error: slice of null pointer +// :13077:9: error: slice of null pointer +// :13081:9: error: slice of null pointer +// :13094:19: error: slice of null pointer +// :13098:19: error: slice of null pointer +// :13114:9: error: slice of null pointer +// :13118:9: error: slice of null pointer +// :13131:19: error: slice of null pointer +// :13135:19: error: slice of null pointer +// :13151:9: error: slice of null pointer +// :13155:9: error: slice of null pointer +// :13168:19: error: slice of null pointer +// :13172:19: error: slice of null pointer +// :13188:9: error: slice of null pointer +// :13192:9: error: slice of null pointer +// :13205:19: error: slice of null pointer +// :13209:19: error: slice of null pointer +// :13226:9: error: slice of null pointer +// :13230:9: error: slice of null pointer +// :13243:19: error: slice of null pointer +// :13247:19: error: slice of null pointer +// :13263:9: error: slice of null pointer +// :13267:9: error: slice of null pointer +// :13280:19: error: slice of null pointer +// :13284:19: error: slice of null pointer +// :13300:9: error: slice of null pointer +// :13304:9: error: slice of null pointer +// :13317:19: error: slice of null pointer +// :13321:19: error: slice of null pointer +// :13337:9: error: slice of null pointer +// :13341:9: error: slice of null pointer +// :13354:19: error: slice of null pointer +// :13358:19: error: slice of null pointer +// :13374:9: error: slice of null pointer +// :13378:9: error: slice of null pointer +// :13391:19: error: slice of null pointer +// :13395:19: error: slice of null pointer +// :13411:9: error: slice of null pointer +// :13415:9: error: slice of null pointer +// :13428:19: error: slice of null pointer +// :13432:19: error: slice of null pointer +// :13436:20: error: bounds out of order: start 3, end 2 +// :13439:20: error: bounds out of order: start 3, end 1 +// :13442:20: error: bounds out of order: start 3, end 2 +// :13445:20: error: bounds out of order: start 3, end 1 +// :13449:20: error: bounds out of order: start 3, end 2 +// :13452:20: error: bounds out of order: start 3, end 1 +// :13455:20: error: bounds out of order: start 3, end 2 +// :13458:20: error: bounds out of order: start 3, end 1 +// :13462:20: error: bounds out of order: start 3, end 2 +// :13465:20: error: bounds out of order: start 3, end 1 +// :13468:20: error: bounds out of order: start 3, end 2 +// :13471:20: error: bounds out of order: start 3, end 1 +// :13504:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13508:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13521:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13525:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13568:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13572:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13585:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13589:20: error: slice start out of bounds of reinterpreted memory: start 3, length 2 +// :13640:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :13644:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :13657:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :13661:20: error: slice sentinel always out of bounds of reinterpreted memory: start 3, length 3 +// :13706:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13710:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13723:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13727:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13761:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :13765:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :13778:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :13782:20: error: slice sentinel always out of bounds of reinterpreted memory: start 1, length 1 +// :13798:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13802:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13815:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13819:20: error: slice start out of bounds of reinterpreted memory: start 3, length 1 +// :13824:20: error: bounds out of order: start 3, end 2 +// :13827:20: error: bounds out of order: start 3, end 1 +// :13830:20: error: bounds out of order: start 3, end 2 +// :13833:20: error: bounds out of order: start 3, end 1 +// :13838:20: error: bounds out of order: start 3, end 2 +// :13841:20: error: bounds out of order: start 3, end 1 +// :13844:20: error: bounds out of order: start 3, end 2 +// :13847:20: error: bounds out of order: start 3, end 1 +// :13852:20: error: bounds out of order: start 3, end 2 +// :13855:20: error: bounds out of order: start 3, end 1 +// :13858:20: error: bounds out of order: start 3, end 2 +// :13861:20: error: bounds out of order: start 3, end 1 diff --git a/test/cases/compile_errors/slice_of_null_pointer.zig b/test/cases/compile_errors/slice_of_null_pointer.zig index 18c4ee8a6b17..5f38f7ea7c9c 100644 --- a/test/cases/compile_errors/slice_of_null_pointer.zig +++ b/test/cases/compile_errors/slice_of_null_pointer.zig @@ -8,4 +8,4 @@ comptime { // error // target=native // -// :5:10: error: slice of null pointer +// :5:9: error: slice of null pointer diff --git a/test/cases/compile_errors/slice_of_single-item_pointer_bounds.zig b/test/cases/compile_errors/slice_of_single-item_pointer_bounds.zig index 8b43842f230b..fa9876dde9b8 100644 --- a/test/cases/compile_errors/slice_of_single-item_pointer_bounds.zig +++ b/test/cases/compile_errors/slice_of_single-item_pointer_bounds.zig @@ -1,10 +1,6 @@ const value: u8 = 1; const ptr = &value; -comptime { - _ = ptr[0..]; -} - comptime { _ = ptr[1..2]; } @@ -31,13 +27,8 @@ export fn entry2() void { // error // -// :5:12: error: slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1] -// :9:13: error: slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1] -// :9:13: note: expected '0', found '1' -// :13:16: error: slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1] -// :13:16: note: expected '1', found '2' -// :17:16: error: end index 2 out of bounds for slice of single-item pointer -// :23:13: error: unable to resolve comptime value -// :23:13: note: slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1] -// :29:16: error: unable to resolve comptime value -// :29:16: note: slice of single-item pointer must have comptime-known bounds [0..0], [0..1], or [1..1] +// :5:16: error: slice end out of bounds: end 2, length 1 +// :9:16: error: slice end out of bounds: end 2, length 1 +// :13:16: error: slice end out of bounds: end 2, length 1 +// :19:13: error: start index of slice of pointer-to-one must be comptime-known +// :25:16: error: end index of slice of pointer-to-one must be comptime-known diff --git a/test/cases/safety/@asyncCall with too small a frame.zig b/test/cases/safety/@asyncCall with too small a frame.zig deleted file mode 100644 index 3d7cdb3b1d02..000000000000 --- a/test/cases/safety/@asyncCall with too small a frame.zig +++ /dev/null @@ -1,26 +0,0 @@ -const std = @import("std"); -const builtin = @import("builtin"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -pub fn main() !void { - if (builtin.zig_backend == .stage1 and builtin.os.tag == .wasi) { - // TODO file a bug for this failure - std.process.exit(0); // skip the test - } - var bytes: [1]u8 align(16) = undefined; - var ptr = other; - _ = &ptr; - var frame = @asyncCall(&bytes, {}, ptr, .{}); - _ = &frame; - return error.TestFailed; -} -fn other() callconv(.Async) void { - suspend {} -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/@alignCast misaligned.zig b/test/cases/safety/alignCast_misaligned.zig similarity index 66% rename from test/cases/safety/@alignCast misaligned.zig rename to test/cases/safety/alignCast_misaligned.zig index ade27c2747a8..fe562e693b33 100644 --- a/test/cases/safety/@alignCast misaligned.zig +++ b/test/cases/safety/alignCast_misaligned.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "incorrect alignment")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var array align(4) = [_]u32{ 0x11111111, 0x11111111 }; const bytes = std.mem.sliceAsBytes(array[0..]); diff --git a/test/cases/safety/array slice sentinel mismatch non-scalar.zig b/test/cases/safety/array slice sentinel mismatch non-scalar.zig deleted file mode 100644 index 5523970168e4..000000000000 --- a/test/cases/safety/array slice sentinel mismatch non-scalar.zig +++ /dev/null @@ -1,21 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected tmp.main.S{ .a = 1 }, found tmp.main.S{ .a = 2 }")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - const S = struct { a: u32 }; - var arr = [_]S{ .{ .a = 1 }, .{ .a = 2 } }; - const s = arr[0..1 :.{ .a = 1 }]; - _ = s; - return error.TestFailed; -} - -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/array slice sentinel mismatch vector.zig b/test/cases/safety/array slice sentinel mismatch vector.zig deleted file mode 100644 index da20d988691f..000000000000 --- a/test/cases/safety/array slice sentinel mismatch vector.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected { 0, 0 }, found { 4, 4 }")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - var buf: [4]@Vector(2, u32) = .{ .{ 1, 1 }, .{ 2, 2 }, .{ 3, 3 }, .{ 4, 4 } }; - const slice = buf[0..3 :.{ 0, 0 }]; - _ = slice; - return error.TestFailed; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/array slice sentinel mismatch.zig b/test/cases/safety/array slice sentinel mismatch.zig deleted file mode 100644 index fc196186732d..000000000000 --- a/test/cases/safety/array slice sentinel mismatch.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - var buf: [4]u8 = .{ 1, 2, 3, 4 }; - const slice = buf[0..3 :0]; - _ = slice; - return error.TestFailed; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/array_slice_sentinel_mismatch.zig b/test/cases/safety/array_slice_sentinel_mismatch.zig new file mode 100644 index 000000000000..dabe854f3189 --- /dev/null +++ b/test/cases/safety/array_slice_sentinel_mismatch.zig @@ -0,0 +1,17 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_null_sentinel) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_null_sentinel', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + var buf: [4]u8 = .{ 1, 2, 3, 4 }; + const slice = buf[0..3 :0]; + _ = slice; + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/awaiting twice.zig b/test/cases/safety/awaiting twice.zig deleted file mode 100644 index 6767ad4e767d..000000000000 --- a/test/cases/safety/awaiting twice.zig +++ /dev/null @@ -1,29 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -var frame: anyframe = undefined; - -pub fn main() !void { - _ = async amain(); - resume frame; - return error.TestFailed; -} - -fn amain() void { - var f = async func(); - await f; - await f; -} - -fn func() void { - suspend { - frame = @frame(); - } -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/bad union field access.zig b/test/cases/safety/bad_union_field_access.zig similarity index 54% rename from test/cases/safety/bad union field access.zig rename to test/cases/safety/bad_union_field_access.zig index c6706d41764d..6b65232c753c 100644 --- a/test/cases/safety/bad union field access.zig +++ b/test/cases/safety/bad_union_field_access.zig @@ -1,24 +1,20 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "access of union field 'float' while field 'int' is active")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_inactive_field) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_inactive_field', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); const Foo = union { float: f32, int: u32, }; - pub fn main() !void { var f = Foo{ .int = 42 }; bar(&f); return error.TestFailed; } - fn bar(f: *Foo) void { f.float = 12.34; } diff --git a/test/cases/safety/calling panic.zig b/test/cases/safety/calling panic.zig deleted file mode 100644 index 832bc5f19ad2..000000000000 --- a/test/cases/safety/calling panic.zig +++ /dev/null @@ -1,16 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "oh no")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - if (true) @panic("oh no"); - return error.TestFailed; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/calling_panic.zig b/test/cases/safety/calling_panic.zig new file mode 100644 index 000000000000..e4b8525aa02f --- /dev/null +++ b/test/cases/safety/calling_panic.zig @@ -0,0 +1,15 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .message) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.message', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + if (true) @panic("oh no"); + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/cast integer to global error and no code matches.zig b/test/cases/safety/cast integer to global error and no code matches.zig deleted file mode 100644 index 61daf07a2ba2..000000000000 --- a/test/cases/safety/cast integer to global error and no code matches.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - bar(9999) catch {}; - return error.TestFailed; -} -fn bar(x: u16) anyerror { - return @errorFromInt(x); -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/cast_integer_to_global_error_and_no_code_matches.zig b/test/cases/safety/cast_integer_to_global_error_and_no_code_matches.zig new file mode 100644 index 000000000000..ab719619e501 --- /dev/null +++ b/test/cases/safety/cast_integer_to_global_error_and_no_code_matches.zig @@ -0,0 +1,18 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_error_from_invalid) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_error_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + bar(9999) catch {}; + return error.TestFailed; +} +fn bar(x: u16) anyerror { + return @errorFromInt(x); +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig b/test/cases/safety/cast_u8_to_bigger_slice_of_wrong_size.zig similarity index 60% rename from test/cases/safety/cast []u8 to bigger slice of wrong size.zig rename to test/cases/safety/cast_u8_to_bigger_slice_of_wrong_size.zig index a72b2fcca2ca..670845a6eec3 100644 --- a/test/cases/safety/cast []u8 to bigger slice of wrong size.zig +++ b/test/cases/safety/cast_u8_to_bigger_slice_of_wrong_size.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .div_with_remainder) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.div_with_remainder', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = widenSlice(&[_]u8{ 1, 2, 3, 4, 5 }); if (x.len == 0) return error.Whatever; diff --git a/test/cases/safety/empty slice with sentinel out of bounds.zig b/test/cases/safety/empty_slice_with_sentinel_out_of_bounds.zig similarity index 52% rename from test/cases/safety/empty slice with sentinel out of bounds.zig rename to test/cases/safety/empty_slice_with_sentinel_out_of_bounds.zig index 69201fde307c..333cd7223864 100644 --- a/test/cases/safety/empty slice with sentinel out of bounds.zig +++ b/test/cases/safety/empty_slice_with_sentinel_out_of_bounds.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 1, len 0")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_out_of_bounds) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_out_of_bounds', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var buf_zero = [0]u8{}; const input: []u8 = &buf_zero; @@ -15,7 +13,6 @@ pub fn main() !void { _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/@enumFromInt - no matching tag value.zig b/test/cases/safety/enumFromInt-no_matching_tag_value.zig similarity index 53% rename from test/cases/safety/@enumFromInt - no matching tag value.zig rename to test/cases/safety/enumFromInt-no_matching_tag_value.zig index 5051869cc0cb..9c5af18cafe4 100644 --- a/test/cases/safety/@enumFromInt - no matching tag value.zig +++ b/test/cases/safety/enumFromInt-no_matching_tag_value.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const Foo = enum { A, B, @@ -20,7 +19,6 @@ fn bar(a: u2) Foo { return @enumFromInt(a); } fn baz(_: Foo) void {} - // run // backend=llvm // target=native diff --git a/test/cases/safety/error return trace across suspend points.zig b/test/cases/safety/error return trace across suspend points.zig deleted file mode 100644 index 2c31aacc9d2f..000000000000 --- a/test/cases/safety/error return trace across suspend points.zig +++ /dev/null @@ -1,38 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} - -var failing_frame: @Frame(failing) = undefined; - -pub fn main() !void { - const p = nonFailing(); - resume p; - const p2 = async printTrace(p); - _ = p2; - return error.TestFailed; -} - -fn nonFailing() anyframe->anyerror!void { - failing_frame = async failing(); - return &failing_frame; -} - -fn failing() anyerror!void { - suspend {} - return second(); -} - -fn second() callconv(.Async) anyerror!void { - return error.Fail; -} - -fn printTrace(p: anyframe->anyerror!void) void { - (await p) catch unreachable; -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/@errorCast error not present in destination.zig b/test/cases/safety/errorCast_error_not_present_in_destination.zig similarity index 54% rename from test/cases/safety/@errorCast error not present in destination.zig rename to test/cases/safety/errorCast_error_not_present_in_destination.zig index ff86e1f78382..b9723616ebaf 100644 --- a/test/cases/safety/@errorCast error not present in destination.zig +++ b/test/cases/safety/errorCast_error_not_present_in_destination.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_error_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_error_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const Set1 = error{ A, B }; const Set2 = error{ A, C }; pub fn main() !void { diff --git a/test/cases/safety/@errorCast error union casted to disjoint set.zig b/test/cases/safety/errorCast_error_union_casted_to_disjoint_set.zig similarity index 51% rename from test/cases/safety/@errorCast error union casted to disjoint set.zig rename to test/cases/safety/errorCast_error_union_casted_to_disjoint_set.zig index c9da2fc636ae..c29c2ec81083 100644 --- a/test/cases/safety/@errorCast error union casted to disjoint set.zig +++ b/test/cases/safety/errorCast_error_union_casted_to_disjoint_set.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_error_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_error_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const bar: error{Foo}!i32 = @errorCast(foo()); _ = &bar; diff --git a/test/cases/safety/exact division failure - vectors.zig b/test/cases/safety/exact_division_failure-vectors.zig similarity index 63% rename from test/cases/safety/exact division failure - vectors.zig rename to test/cases/safety/exact_division_failure-vectors.zig index c5df2b276f17..db79ba46225f 100644 --- a/test/cases/safety/exact division failure - vectors.zig +++ b/test/cases/safety/exact_division_failure-vectors.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .div_with_remainder) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.div_with_remainder', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const a: @Vector(4, i32) = [4]i32{ 111, 222, 333, 444 }; const b: @Vector(4, i32) = [4]i32{ 111, 222, 333, 441 }; diff --git a/test/cases/safety/exact division failure.zig b/test/cases/safety/exact_division_failure.zig similarity index 55% rename from test/cases/safety/exact division failure.zig rename to test/cases/safety/exact_division_failure.zig index cdf1b1fb8d31..49cb3e52d64f 100644 --- a/test/cases/safety/exact division failure.zig +++ b/test/cases/safety/exact_division_failure.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "exact division produced remainder")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .div_with_remainder) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.div_with_remainder', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = divExact(10, 3); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/for_len_mismatch.zig b/test/cases/safety/for_len_mismatch.zig index ee21b947d7ee..ec37887be1f1 100644 --- a/test/cases/safety/for_len_mismatch.zig +++ b/test/cases/safety/for_len_mismatch.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_for_loop_capture_lengths) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_for_loop_capture_lengths', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var runtime_i: usize = 1; var j: usize = 3; diff --git a/test/cases/safety/for_len_mismatch_three.zig b/test/cases/safety/for_len_mismatch_three.zig index 70f854def51f..49c4d811de48 100644 --- a/test/cases/safety/for_len_mismatch_three.zig +++ b/test/cases/safety/for_len_mismatch_three.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "for loop over objects with non-equal lengths")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_for_loop_capture_lengths) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_for_loop_capture_lengths', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var slice: []const u8 = "hello"; _ = &slice; diff --git a/test/cases/safety/ignored expression integer overflow.zig b/test/cases/safety/ignored expression integer overflow.zig deleted file mode 100644 index f8e3f0bf0aa6..000000000000 --- a/test/cases/safety/ignored expression integer overflow.zig +++ /dev/null @@ -1,21 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - var x: usize = undefined; - x = 0; - // We ignore this result but it should still trigger a safety panic! - _ = x - 1; - return error.TestFailed; -} - -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/@intCast to u0.zig b/test/cases/safety/intCast_to_u0.zig similarity index 52% rename from test/cases/safety/@intCast to u0.zig rename to test/cases/safety/intCast_to_u0.zig index a33da87f0fa8..2fd57e970a05 100644 --- a/test/cases/safety/@intCast to u0.zig +++ b/test/cases/safety/intCast_to_u0.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { bar(1, 1); return error.TestFailed; diff --git a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig b/test/cases/safety/intFromFloat_cannot_fit-negative_out_of_range.zig similarity index 50% rename from test/cases/safety/@intFromFloat cannot fit - negative out of range.zig rename to test/cases/safety/intFromFloat_cannot_fit-negative_out_of_range.zig index a5a8d831b337..6d5ca70adfc0 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative out of range.zig +++ b/test/cases/safety/intFromFloat_cannot_fit-negative_out_of_range.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_int_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_int_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { baz(bar(-129.1)); return error.TestFailed; diff --git a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig b/test/cases/safety/intFromFloat_cannot_fit-negative_to_unsigned.zig similarity index 50% rename from test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig rename to test/cases/safety/intFromFloat_cannot_fit-negative_to_unsigned.zig index 1bf1a667659f..72fd9126ab5a 100644 --- a/test/cases/safety/@intFromFloat cannot fit - negative to unsigned.zig +++ b/test/cases/safety/intFromFloat_cannot_fit-negative_to_unsigned.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_int_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_int_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { baz(bar(-1.1)); return error.TestFailed; diff --git a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig b/test/cases/safety/intFromFloat_cannot_fit-positive_out_of_range.zig similarity index 50% rename from test/cases/safety/@intFromFloat cannot fit - positive out of range.zig rename to test/cases/safety/intFromFloat_cannot_fit-positive_out_of_range.zig index 15a9fa7ad188..bb146dca6fe6 100644 --- a/test/cases/safety/@intFromFloat cannot fit - positive out of range.zig +++ b/test/cases/safety/intFromFloat_cannot_fit-positive_out_of_range.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer part of floating point value out of bounds")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_int_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_int_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { baz(bar(256.2)); return error.TestFailed; diff --git a/test/cases/safety/integer addition overflow.zig b/test/cases/safety/integer_addition_overflow.zig similarity index 54% rename from test/cases/safety/integer addition overflow.zig rename to test/cases/safety/integer_addition_overflow.zig index 4f7c5b2cb3f5..4f68268397c9 100644 --- a/test/cases/safety/integer addition overflow.zig +++ b/test/cases/safety/integer_addition_overflow.zig @@ -1,23 +1,19 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = add(65530, 10); if (x == 0) return error.Whatever; return error.TestFailed; } - fn add(a: u16, b: u16) u16 { return a + b; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/integer division by zero - vectors.zig b/test/cases/safety/integer_division_by_zero-vectors.zig similarity index 63% rename from test/cases/safety/integer division by zero - vectors.zig rename to test/cases/safety/integer_division_by_zero-vectors.zig index 6e2af616b909..7192d907d3c4 100644 --- a/test/cases/safety/integer division by zero - vectors.zig +++ b/test/cases/safety/integer_division_by_zero-vectors.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .divided_by_zero) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.divided_by_zero', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const a: @Vector(4, i32) = [4]i32{ 111, 222, 333, 444 }; const b: @Vector(4, i32) = [4]i32{ 111, 0, 333, 444 }; diff --git a/test/cases/safety/integer division by zero.zig b/test/cases/safety/integer_division_by_zero.zig similarity index 52% rename from test/cases/safety/integer division by zero.zig rename to test/cases/safety/integer_division_by_zero.zig index 0d1b79d26d8f..6bf696bee821 100644 --- a/test/cases/safety/integer division by zero.zig +++ b/test/cases/safety/integer_division_by_zero.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .divided_by_zero) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.divided_by_zero', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const x = div0(999, 0); _ = x; diff --git a/test/cases/safety/integer multiplication overflow.zig b/test/cases/safety/integer_multiplication_overflow.zig similarity index 54% rename from test/cases/safety/integer multiplication overflow.zig rename to test/cases/safety/integer_multiplication_overflow.zig index 641801277dbd..d355417eac7b 100644 --- a/test/cases/safety/integer multiplication overflow.zig +++ b/test/cases/safety/integer_multiplication_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mul_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mul_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = mul(300, 6000); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/integer negation overflow.zig b/test/cases/safety/integer_negation_overflow.zig similarity index 53% rename from test/cases/safety/integer negation overflow.zig rename to test/cases/safety/integer_negation_overflow.zig index 3d4c134c4a68..5fd3efb4b5fc 100644 --- a/test/cases/safety/integer negation overflow.zig +++ b/test/cases/safety/integer_negation_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .sub_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.sub_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = neg(-32768); if (x == 32767) return error.Whatever; diff --git a/test/cases/safety/integer subtraction overflow.zig b/test/cases/safety/integer_subtraction_overflow.zig similarity index 54% rename from test/cases/safety/integer subtraction overflow.zig rename to test/cases/safety/integer_subtraction_overflow.zig index 84a16f55b870..d1777e4e3457 100644 --- a/test/cases/safety/integer subtraction overflow.zig +++ b/test/cases/safety/integer_subtraction_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .sub_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.sub_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = sub(10, 20); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/invalid resume of async function.zig b/test/cases/safety/invalid resume of async function.zig deleted file mode 100644 index c58f13b99d05..000000000000 --- a/test/cases/safety/invalid resume of async function.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -pub fn main() !void { - var p = async suspendOnce(); - resume p; //ok - resume p; //bad - return error.TestFailed; -} -fn suspendOnce() void { - suspend {} -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/memcpy_alias.zig b/test/cases/safety/memcpy_alias.zig index d87a7bf6aa4d..c2c1ed9eb455 100644 --- a/test/cases/safety/memcpy_alias.zig +++ b/test/cases/safety/memcpy_alias.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "@memcpy arguments alias")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .memcpy_argument_aliasing) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.memcpy_argument_aliasing', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [2]u8{ 1, 2 } ** 5; var len: usize = 5; diff --git a/test/cases/safety/memcpy_len_mismatch.zig b/test/cases/safety/memcpy_len_mismatch.zig index 6ca36abccbbf..54b3b4dd11e8 100644 --- a/test/cases/safety/memcpy_len_mismatch.zig +++ b/test/cases/safety/memcpy_len_mismatch.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "@memcpy arguments have non-equal lengths")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_memcpy_argument_lengths) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_memcpy_argument_lengths', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [2]u8{ 1, 2 } ** 5; var len: usize = 5; diff --git a/test/cases/safety/memset_array_undefined_bytes.zig b/test/cases/safety/memset_array_undefined_bytes.zig index e0ce2dac0443..3cc6c5fdd262 100644 --- a/test/cases/safety/memset_array_undefined_bytes.zig +++ b/test/cases/safety/memset_array_undefined_bytes.zig @@ -1,14 +1,14 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [6]u8{ 1, 2, 3, 4, 5, 6 }; + _ = &buffer; @memset(&buffer, undefined); var x: u8 = buffer[1]; x += buffer[2]; diff --git a/test/cases/safety/memset_array_undefined_large.zig b/test/cases/safety/memset_array_undefined_large.zig index dbc1cf442024..93d5cbd7d55e 100644 --- a/test/cases/safety/memset_array_undefined_large.zig +++ b/test/cases/safety/memset_array_undefined_large.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [6]i32{ 1, 2, 3, 4, 5, 6 }; @memset(&buffer, undefined); diff --git a/test/cases/safety/memset_slice_undefined_bytes.zig b/test/cases/safety/memset_slice_undefined_bytes.zig index 4214b5db4b76..bc159553ba48 100644 --- a/test/cases/safety/memset_slice_undefined_bytes.zig +++ b/test/cases/safety/memset_slice_undefined_bytes.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [6]u8{ 1, 2, 3, 4, 5, 6 }; var len = buffer.len; @@ -14,6 +13,7 @@ pub fn main() !void { @memset(buffer[0..len], undefined); var x: u8 = buffer[1]; x += buffer[2]; + return error.TestFailed; } // run // backend=llvm diff --git a/test/cases/safety/memset_slice_undefined_large.zig b/test/cases/safety/memset_slice_undefined_large.zig index d1f4f651d33b..cd9be84aef0f 100644 --- a/test/cases/safety/memset_slice_undefined_large.zig +++ b/test/cases/safety/memset_slice_undefined_large.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buffer = [6]i32{ 1, 2, 3, 4, 5, 6 }; var len = buffer.len; diff --git a/test/cases/safety/modrem by zero.zig b/test/cases/safety/modrem_by_zero.zig similarity index 51% rename from test/cases/safety/modrem by zero.zig rename to test/cases/safety/modrem_by_zero.zig index f201062c0e8f..6b1c1d09d1b2 100644 --- a/test/cases/safety/modrem by zero.zig +++ b/test/cases/safety/modrem_by_zero.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .divided_by_zero) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.divided_by_zero', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const x = div0(999, 0); _ = x; diff --git a/test/cases/safety/modulus by zero.zig b/test/cases/safety/modulus_by_zero.zig similarity index 52% rename from test/cases/safety/modulus by zero.zig rename to test/cases/safety/modulus_by_zero.zig index 6714458979d0..81fe5c85d533 100644 --- a/test/cases/safety/modulus by zero.zig +++ b/test/cases/safety/modulus_by_zero.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .divided_by_zero) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.divided_by_zero', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const x = mod0(999, 0); _ = x; diff --git a/test/cases/safety/noreturn returned.zig b/test/cases/safety/noreturn_returned.zig similarity index 51% rename from test/cases/safety/noreturn returned.zig rename to test/cases/safety/noreturn_returned.zig index c3c30af37ee4..e817ba9d65bc 100644 --- a/test/cases/safety/noreturn returned.zig +++ b/test/cases/safety/noreturn_returned.zig @@ -1,18 +1,16 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "'noreturn' function returned")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .returned_noreturn) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.returned_noreturn', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const T = struct { export fn bar() void { // ... } }; - extern fn bar() noreturn; pub fn main() void { _ = T.bar; diff --git a/test/cases/safety/nosuspend function call, callee suspends.zig b/test/cases/safety/nosuspend function call, callee suspends.zig deleted file mode 100644 index 50f457f31458..000000000000 --- a/test/cases/safety/nosuspend function call, callee suspends.zig +++ /dev/null @@ -1,20 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -pub fn main() !void { - _ = nosuspend add(101, 100); - return error.TestFailed; -} -fn add(a: i32, b: i32) i32 { - if (a > 100) { - suspend {} - } - return a + b; -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/optional unwrap operator on C pointer.zig b/test/cases/safety/optional unwrap operator on C pointer.zig deleted file mode 100644 index bd3313265a50..000000000000 --- a/test/cases/safety/optional unwrap operator on C pointer.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - var ptr: [*c]i32 = null; - _ = &ptr; - const b = ptr.?; - _ = b; - return error.TestFailed; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/optional unwrap operator on null pointer.zig b/test/cases/safety/optional unwrap operator on null pointer.zig deleted file mode 100644 index 9dda4d0a9e07..000000000000 --- a/test/cases/safety/optional unwrap operator on null pointer.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - var ptr: ?*i32 = null; - _ = &ptr; - const b = ptr.?; - _ = b; - return error.TestFailed; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/optional_unwrap_operator_on_C_pointer.zig b/test/cases/safety/optional_unwrap_operator_on_C_pointer.zig new file mode 100644 index 000000000000..39f6013566a1 --- /dev/null +++ b/test/cases/safety/optional_unwrap_operator_on_C_pointer.zig @@ -0,0 +1,18 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_null_value) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_null_value', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + var ptr: [*c]i32 = null; + _ = &ptr; + const b = ptr.?; + _ = b; + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/optional_unwrap_operator_on_null_pointer.zig b/test/cases/safety/optional_unwrap_operator_on_null_pointer.zig new file mode 100644 index 000000000000..079650f7c92d --- /dev/null +++ b/test/cases/safety/optional_unwrap_operator_on_null_pointer.zig @@ -0,0 +1,18 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_null_value) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_null_value', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + var ptr: ?*i32 = null; + _ = &ptr; + const b = ptr.?; + _ = b; + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/out of bounds array slice by length.zig b/test/cases/safety/out of bounds array slice by length.zig deleted file mode 100644 index 62768abebf60..000000000000 --- a/test/cases/safety/out of bounds array slice by length.zig +++ /dev/null @@ -1,20 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 16, len 5")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - var buf: [5]u8 = undefined; - _ = buf[foo(6)..][0..10]; - return error.TestFailed; -} -fn foo(a: u32) u32 { - return a; -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/out of bounds slice access.zig b/test/cases/safety/out_of_bounds_slice_access.zig similarity index 53% rename from test/cases/safety/out of bounds slice access.zig rename to test/cases/safety/out_of_bounds_slice_access.zig index b4c87948a5ce..94c3a9e192eb 100644 --- a/test/cases/safety/out of bounds slice access.zig +++ b/test/cases/safety/out_of_bounds_slice_access.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 4, len 4")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_out_of_bounds) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_out_of_bounds', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const a = [_]i32{ 1, 2, 3, 4 }; baz(bar(&a)); diff --git a/test/cases/safety/pointer casting null to non-optional pointer.zig b/test/cases/safety/pointer_casting_null_to_non-optional_pointer.zig similarity index 50% rename from test/cases/safety/pointer casting null to non-optional pointer.zig rename to test/cases/safety/pointer_casting_null_to_non-optional_pointer.zig index fdf8dc17ce27..98c67ab45c78 100644 --- a/test/cases/safety/pointer casting null to non-optional pointer.zig +++ b/test/cases/safety/pointer_casting_null_to_non-optional_pointer.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var c_ptr: [*c]u8 = 0; _ = &c_ptr; @@ -15,7 +13,6 @@ pub fn main() !void { _ = zig_ptr; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/pointer casting to null function pointer.zig b/test/cases/safety/pointer_casting_to_null_function_pointer.zig similarity index 58% rename from test/cases/safety/pointer casting to null function pointer.zig rename to test/cases/safety/pointer_casting_to_null_function_pointer.zig index 8f399b66dc27..cd7f6289e4b2 100644 --- a/test/cases/safety/pointer casting to null function pointer.zig +++ b/test/cases/safety/pointer_casting_to_null_function_pointer.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); fn getNullPtr() ?*const anyopaque { return null; } @@ -17,7 +15,6 @@ pub fn main() !void { _ = required_ptr; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/pointer slice sentinel mismatch.zig b/test/cases/safety/pointer_slice_sentinel_mismatch.zig similarity index 52% rename from test/cases/safety/pointer slice sentinel mismatch.zig rename to test/cases/safety/pointer_slice_sentinel_mismatch.zig index 3972528edf42..2f07f9ec1515 100644 --- a/test/cases/safety/pointer slice sentinel mismatch.zig +++ b/test/cases/safety/pointer_slice_sentinel_mismatch.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_null_sentinel) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_null_sentinel', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var buf: [4]u8 = .{ 1, 2, 3, 4 }; const ptr: [*]u8 = &buf; @@ -15,7 +13,6 @@ pub fn main() !void { _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig b/test/cases/safety/ptrFromInt_address_zero_to_non-optional_byte-aligned_pointer.zig similarity index 50% rename from test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig rename to test/cases/safety/ptrFromInt_address_zero_to_non-optional_byte-aligned_pointer.zig index f8c448855e34..fc596a89dade 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional byte-aligned pointer.zig +++ b/test/cases/safety/ptrFromInt_address_zero_to_non-optional_byte-aligned_pointer.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var zero: usize = 0; _ = &zero; diff --git a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig b/test/cases/safety/ptrFromInt_address_zero_to_non-optional_pointer.zig similarity index 50% rename from test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig rename to test/cases/safety/ptrFromInt_address_zero_to_non-optional_pointer.zig index c9ae253df7ba..bd88a8a05dad 100644 --- a/test/cases/safety/@ptrFromInt address zero to non-optional pointer.zig +++ b/test/cases/safety/ptrFromInt_address_zero_to_non-optional_pointer.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "cast causes pointer to be null")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var zero: usize = 0; _ = &zero; diff --git a/test/cases/safety/@ptrFromInt with misaligned address.zig b/test/cases/safety/ptrFromInt_with_misaligned_address.zig similarity index 50% rename from test/cases/safety/@ptrFromInt with misaligned address.zig rename to test/cases/safety/ptrFromInt_with_misaligned_address.zig index 3952ab9baa2f..0a5bd149f29c 100644 --- a/test/cases/safety/@ptrFromInt with misaligned address.zig +++ b/test/cases/safety/ptrFromInt_with_misaligned_address.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "incorrect alignment")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_ptr_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_ptr_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var x: usize = 5; _ = &x; diff --git a/test/cases/safety/remainder division by zero.zig b/test/cases/safety/remainder_division_by_zero.zig similarity index 50% rename from test/cases/safety/remainder division by zero.zig rename to test/cases/safety/remainder_division_by_zero.zig index 3dc97f6e16fd..eb392707ca74 100644 --- a/test/cases/safety/remainder division by zero.zig +++ b/test/cases/safety/remainder_division_by_zero.zig @@ -1,13 +1,13 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "division by zero")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .divided_by_zero) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.divided_by_zero', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { + if (return) {} const x = rem0(999, 0); _ = x; return error.TestFailed; diff --git a/test/cases/safety/resuming a function which is awaiting a call.zig b/test/cases/safety/resuming a function which is awaiting a call.zig deleted file mode 100644 index 47545584eaf1..000000000000 --- a/test/cases/safety/resuming a function which is awaiting a call.zig +++ /dev/null @@ -1,21 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -pub fn main() !void { - var frame = async first(); - resume frame; - return error.TestFailed; -} -fn first() void { - other(); -} -fn other() void { - suspend {} -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/resuming a function which is awaiting a frame.zig b/test/cases/safety/resuming a function which is awaiting a frame.zig deleted file mode 100644 index 26df1ae900b4..000000000000 --- a/test/cases/safety/resuming a function which is awaiting a frame.zig +++ /dev/null @@ -1,22 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -pub fn main() !void { - var frame = async first(); - resume frame; - return error.TestFailed; -} -fn first() void { - var frame = async other(); - await frame; -} -fn other() void { - suspend {} -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig b/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig deleted file mode 100644 index f8bf6d44c08f..000000000000 --- a/test/cases/safety/resuming a non-suspended function which has been suspended and resumed.zig +++ /dev/null @@ -1,32 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -fn foo() void { - suspend { - global_frame = @frame(); - } - var f = async bar(@frame()); - _ = &f; - std.process.exit(1); -} - -fn bar(frame: anyframe) void { - suspend { - resume frame; - } - std.process.exit(1); -} - -var global_frame: anyframe = undefined; -pub fn main() !void { - _ = async foo(); - resume global_frame; - std.process.exit(1); -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/resuming a non-suspended function which never been suspended.zig b/test/cases/safety/resuming a non-suspended function which never been suspended.zig deleted file mode 100644 index af288ab8ba39..000000000000 --- a/test/cases/safety/resuming a non-suspended function which never been suspended.zig +++ /dev/null @@ -1,27 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = message; - _ = stack_trace; - std.process.exit(0); -} -fn foo() void { - var f = async bar(@frame()); - _ = &f; - std.process.exit(1); -} - -fn bar(frame: anyframe) void { - suspend { - resume frame; - } - std.process.exit(1); -} - -pub fn main() !void { - _ = async foo(); - return error.TestFailed; -} -// run -// backend=stage1 -// target=native diff --git a/test/cases/safety/shift left by huge amount.zig b/test/cases/safety/shift left by huge amount.zig deleted file mode 100644 index a038c0ee4442..000000000000 --- a/test/cases/safety/shift left by huge amount.zig +++ /dev/null @@ -1,22 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - var x: u24 = 42; - var y: u5 = 24; - _ = .{ &x, &y }; - const z = x >> y; - _ = z; - return error.TestFailed; -} - -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/shift right by huge amount.zig b/test/cases/safety/shift_left_by_huge_amount.zig similarity index 51% rename from test/cases/safety/shift right by huge amount.zig rename to test/cases/safety/shift_left_by_huge_amount.zig index ced81d948d48..eb731c74231f 100644 --- a/test/cases/safety/shift right by huge amount.zig +++ b/test/cases/safety/shift_left_by_huge_amount.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "shift amount is greater than the type size")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shift_amt_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.shift_amt_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var x: u24 = 42; var y: u5 = 24; @@ -16,7 +14,6 @@ pub fn main() !void { _ = z; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/shift_right_by_huge_amount.zig b/test/cases/safety/shift_right_by_huge_amount.zig new file mode 100644 index 000000000000..eb731c74231f --- /dev/null +++ b/test/cases/safety/shift_right_by_huge_amount.zig @@ -0,0 +1,19 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shift_amt_overflowed) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.shift_amt_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + var x: u24 = 42; + var y: u5 = 24; + _ = .{ &x, &y }; + const z = x << y; + _ = z; + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/signed-unsigned vector cast.zig b/test/cases/safety/signed-unsigned_vector_cast.zig similarity index 51% rename from test/cases/safety/signed-unsigned vector cast.zig rename to test/cases/safety/signed-unsigned_vector_cast.zig index 2e3b4d25d52d..e24636b41b94 100644 --- a/test/cases/safety/signed-unsigned vector cast.zig +++ b/test/cases/safety/signed-unsigned_vector_cast.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_unsigned_from_negative) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_unsigned_from_negative', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var x: @Vector(4, i32) = @splat(-2147483647); _ = &x; @@ -15,7 +13,6 @@ pub fn main() !void { _ = y; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/signed integer division overflow - vectors.zig b/test/cases/safety/signed_integer_division_overflow-vectors.zig similarity index 64% rename from test/cases/safety/signed integer division overflow - vectors.zig rename to test/cases/safety/signed_integer_division_overflow-vectors.zig index 6346d9f1a1dd..afb3fb6d0aed 100644 --- a/test/cases/safety/signed integer division overflow - vectors.zig +++ b/test/cases/safety/signed_integer_division_overflow-vectors.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .div_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.div_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const a: @Vector(4, i16) = [_]i16{ 1, 2, -32768, 4 }; const b: @Vector(4, i16) = [_]i16{ 1, 2, -1, 4 }; diff --git a/test/cases/safety/signed integer division overflow.zig b/test/cases/safety/signed_integer_division_overflow.zig similarity index 55% rename from test/cases/safety/signed integer division overflow.zig rename to test/cases/safety/signed_integer_division_overflow.zig index 9d1014ceec08..028325aa26c8 100644 --- a/test/cases/safety/signed integer division overflow.zig +++ b/test/cases/safety/signed_integer_division_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .div_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.div_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = div(-32768, -1); if (x == 32767) return error.Whatever; diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig b/test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer-widening.zig similarity index 50% rename from test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig rename to test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer-widening.zig index 87c812eddc20..200eb35ca11e 100644 --- a/test/cases/safety/signed integer not fitting in cast to unsigned integer - widening.zig +++ b/test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer-widening.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_unsigned_from_negative) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_unsigned_from_negative', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var value: c_short = -1; _ = &value; diff --git a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig b/test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer.zig similarity index 52% rename from test/cases/safety/signed integer not fitting in cast to unsigned integer.zig rename to test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer.zig index 5d8c3f88c8a3..498280727eca 100644 --- a/test/cases/safety/signed integer not fitting in cast to unsigned integer.zig +++ b/test/cases/safety/signed_integer_not_fitting_in_cast_to_unsigned_integer.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to cast negative value to unsigned integer")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_unsigned_from_negative) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_unsigned_from_negative', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const x = unsigned_cast(-10); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/signed shift left overflow.zig b/test/cases/safety/signed_shift_left_overflow.zig similarity index 55% rename from test/cases/safety/signed shift left overflow.zig rename to test/cases/safety/signed_shift_left_overflow.zig index f9a4db81ce92..90d88370732b 100644 --- a/test/cases/safety/signed shift left overflow.zig +++ b/test/cases/safety/signed_shift_left_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "left shift overflowed bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shl_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.shl_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shl(-16385, 1); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/signed shift right overflow.zig b/test/cases/safety/signed_shift_right_overflow.zig similarity index 55% rename from test/cases/safety/signed shift right overflow.zig rename to test/cases/safety/signed_shift_right_overflow.zig index 7d71b9ffbde3..7260eda9236e 100644 --- a/test/cases/safety/signed shift right overflow.zig +++ b/test/cases/safety/signed_shift_right_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "right shift overflowed bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shr_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.shr_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shr(-16385, 1); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig b/test/cases/safety/slice with sentinel out of bounds - runtime len.zig deleted file mode 100644 index abb3cc42f092..000000000000 --- a/test/cases/safety/slice with sentinel out of bounds - runtime len.zig +++ /dev/null @@ -1,23 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { - std.process.exit(0); - } - std.process.exit(1); -} - -pub fn main() !void { - var buf = [4]u8{ 'a', 'b', 'c', 0 }; - const input: []u8 = &buf; - var len: usize = 4; - _ = &len; - const slice = input[0..len :0]; - _ = slice; - return error.TestFailed; -} - -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/slice_runtime_panic_variants.zig b/test/cases/safety/slice_runtime_panic_variants.zig new file mode 100644 index 000000000000..475043ea3932 --- /dev/null +++ b/test/cases/safety/slice_runtime_panic_variants.zig @@ -0,0 +1,9831 @@ +const std = @import("std"); +var test_idx: usize = 0; +var expect_id: std.builtin.PanicId = .message; +pub fn panic2(found_id: anytype) noreturn { + if (@TypeOf(found_id) != []const u8) { + if (found_id != expect_id) { + std.process.exit(1); + } + test_idx += 1; + if (test_idx == test_fns.len) { + std.process.exit(0); + } + } + test_fns[test_idx](); + std.process.exit(1); +} +var dest_end: usize = 0; +var dest_start: usize = 0; +var dest_len: usize = 0; +var src_mem0: [2]u8 = undefined; +const src_ptr0: *[2]u8 = src_mem0[0..2]; +fn fn0() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr0[0..dest_end]; +} +fn fn1() void { + dest_len = 3; + _ = src_ptr0[0..][0..dest_len]; +} +fn fn2() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr0[1..dest_end]; +} +fn fn3() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr0[1..][0..dest_len]; +} +var src_mem1: [3]u8 = undefined; +const src_ptr1: *[3]u8 = src_mem1[0..3]; +fn fn4() void { + _ = src_ptr1[1..][0..dest_len]; +} +fn fn5() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr1[3..dest_end]; +} +fn fn6() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr1[3..][0..dest_len]; +} +fn fn7() void { + dest_len = 1; + _ = src_ptr1[3..][0..dest_len]; +} +var src_mem2: [1]u8 = undefined; +const src_ptr2: *[1]u8 = src_mem2[0..1]; +fn fn8() void { + dest_end = 3; + _ = src_ptr2[0..dest_end]; +} +fn fn9() void { + dest_len = 3; + _ = src_ptr2[0..][0..dest_len]; +} +fn fn10() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr2[1..dest_end]; +} +fn fn11() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr2[1..][0..dest_len]; +} +fn fn12() void { + dest_len = 1; + _ = src_ptr2[1..][0..dest_len]; +} +var src_mem3: [2]u8 = undefined; +var src_ptr3: *[2]u8 = src_mem3[0..2]; +fn fn13() void { + _ = src_ptr3[0..dest_end]; +} +fn fn14() void { + dest_len = 3; + _ = src_ptr3[0..][0..dest_len]; +} +fn fn15() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr3[1..dest_end]; +} +fn fn16() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr3[1..][0..dest_len]; +} +var src_mem4: [3]u8 = undefined; +var src_ptr4: *[3]u8 = src_mem4[0..3]; +fn fn17() void { + _ = src_ptr4[1..][0..dest_len]; +} +fn fn18() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr4[3..dest_end]; +} +fn fn19() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr4[3..][0..dest_len]; +} +fn fn20() void { + dest_len = 1; + _ = src_ptr4[3..][0..dest_len]; +} +var src_mem5: [1]u8 = undefined; +var src_ptr5: *[1]u8 = src_mem5[0..1]; +fn fn21() void { + dest_end = 3; + _ = src_ptr5[0..dest_end]; +} +fn fn22() void { + dest_len = 3; + _ = src_ptr5[0..][0..dest_len]; +} +fn fn23() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr5[1..dest_end]; +} +fn fn24() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr5[1..][0..dest_len]; +} +fn fn25() void { + dest_len = 1; + _ = src_ptr5[1..][0..dest_len]; +} +const src_ptr6: []u8 = src_mem0[0..2]; +fn fn26() void { + _ = src_ptr6[0..dest_end]; +} +fn fn27() void { + dest_len = 3; + _ = src_ptr6[0..][0..dest_len]; +} +fn fn28() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr6[1..dest_end]; +} +fn fn29() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr6[1..][0..dest_len]; +} +const src_ptr7: []u8 = src_mem1[0..3]; +fn fn30() void { + _ = src_ptr7[1..][0..dest_len]; +} +fn fn31() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr7[3..dest_end]; +} +fn fn32() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr7[3..][0..dest_len]; +} +fn fn33() void { + dest_len = 1; + _ = src_ptr7[3..][0..dest_len]; +} +const src_ptr8: []u8 = src_mem2[0..1]; +fn fn34() void { + dest_end = 3; + _ = src_ptr8[0..dest_end]; +} +fn fn35() void { + dest_len = 3; + _ = src_ptr8[0..][0..dest_len]; +} +fn fn36() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr8[1..dest_end]; +} +fn fn37() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr8[1..][0..dest_len]; +} +fn fn38() void { + dest_len = 1; + _ = src_ptr8[1..][0..dest_len]; +} +var src_mem6: [2]u8 = undefined; +var src_ptr9: []u8 = src_mem6[0..2]; +fn fn39() void { + _ = src_ptr9[0..3]; +} +fn fn40() void { + _ = src_ptr9[0..dest_end]; +} +fn fn41() void { + _ = src_ptr9[0..][0..3]; +} +fn fn42() void { + dest_len = 3; + _ = src_ptr9[0..][0..dest_len]; +} +fn fn43() void { + _ = src_ptr9[1..3]; +} +fn fn44() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr9[1..dest_end]; +} +fn fn45() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr9[1..][0..2]; +} +fn fn46() void { + _ = src_ptr9[1..][0..3]; +} +fn fn47() void { + _ = src_ptr9[1..][0..dest_len]; +} +fn fn48() void { + expect_id = .accessed_out_of_order; + _ = src_ptr9[3..]; +} +fn fn49() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr9[3..3]; +} +fn fn50() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr9[3..dest_end]; +} +fn fn51() void { + dest_end = 1; + _ = src_ptr9[3..dest_end]; +} +fn fn52() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr9[3..][0..2]; +} +fn fn53() void { + _ = src_ptr9[3..][0..3]; +} +fn fn54() void { + _ = src_ptr9[3..][0..1]; +} +fn fn55() void { + _ = src_ptr9[3..][0..dest_len]; +} +fn fn56() void { + dest_len = 1; + _ = src_ptr9[3..][0..dest_len]; +} +var src_mem7: [3]u8 = undefined; +var src_ptr10: []u8 = src_mem7[0..3]; +fn fn57() void { + _ = src_ptr10[1..][0..3]; +} +fn fn58() void { + dest_len = 3; + _ = src_ptr10[1..][0..dest_len]; +} +fn fn59() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr10[3..dest_end]; +} +fn fn60() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr10[3..][0..2]; +} +fn fn61() void { + _ = src_ptr10[3..][0..3]; +} +fn fn62() void { + _ = src_ptr10[3..][0..1]; +} +fn fn63() void { + _ = src_ptr10[3..][0..dest_len]; +} +fn fn64() void { + dest_len = 1; + _ = src_ptr10[3..][0..dest_len]; +} +var src_mem8: [1]u8 = undefined; +var src_ptr11: []u8 = src_mem8[0..1]; +fn fn65() void { + _ = src_ptr11[0..2]; +} +fn fn66() void { + _ = src_ptr11[0..3]; +} +fn fn67() void { + dest_end = 3; + _ = src_ptr11[0..dest_end]; +} +fn fn68() void { + _ = src_ptr11[0..][0..2]; +} +fn fn69() void { + _ = src_ptr11[0..][0..3]; +} +fn fn70() void { + dest_len = 3; + _ = src_ptr11[0..][0..dest_len]; +} +fn fn71() void { + _ = src_ptr11[1..2]; +} +fn fn72() void { + _ = src_ptr11[1..3]; +} +fn fn73() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr11[1..dest_end]; +} +fn fn74() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr11[1..][0..2]; +} +fn fn75() void { + _ = src_ptr11[1..][0..3]; +} +fn fn76() void { + _ = src_ptr11[1..][0..1]; +} +fn fn77() void { + _ = src_ptr11[1..][0..dest_len]; +} +fn fn78() void { + dest_len = 1; + _ = src_ptr11[1..][0..dest_len]; +} +fn fn79() void { + expect_id = .accessed_out_of_order; + _ = src_ptr11[3..]; +} +fn fn80() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr11[3..3]; +} +fn fn81() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr11[3..dest_end]; +} +fn fn82() void { + dest_end = 1; + _ = src_ptr11[3..dest_end]; +} +fn fn83() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr11[3..][0..2]; +} +fn fn84() void { + _ = src_ptr11[3..][0..3]; +} +fn fn85() void { + _ = src_ptr11[3..][0..1]; +} +fn fn86() void { + dest_len = 3; + _ = src_ptr11[3..][0..dest_len]; +} +fn fn87() void { + dest_len = 1; + _ = src_ptr11[3..][0..dest_len]; +} +var nullptr: [*c]u8 = null; +var src_ptr12: [*c]u8 = null; +fn fn88() void { + expect_id = .accessed_null_value; + _ = src_ptr12[0..]; +} +fn fn89() void { + _ = src_ptr12[0..2]; +} +fn fn90() void { + _ = src_ptr12[0..3]; +} +fn fn91() void { + _ = src_ptr12[0..1]; +} +fn fn92() void { + dest_end = 3; + _ = src_ptr12[0..dest_end]; +} +fn fn93() void { + dest_end = 1; + _ = src_ptr12[0..dest_end]; +} +fn fn94() void { + _ = src_ptr12[0..][0..2]; +} +fn fn95() void { + _ = src_ptr12[0..][0..3]; +} +fn fn96() void { + _ = src_ptr12[0..][0..1]; +} +fn fn97() void { + dest_len = 3; + _ = src_ptr12[0..][0..dest_len]; +} +fn fn98() void { + dest_len = 1; + _ = src_ptr12[0..][0..dest_len]; +} +fn fn99() void { + _ = src_ptr12[1..]; +} +fn fn100() void { + _ = src_ptr12[1..2]; +} +fn fn101() void { + _ = src_ptr12[1..3]; +} +fn fn102() void { + _ = src_ptr12[1..1]; +} +fn fn103() void { + dest_end = 3; + _ = src_ptr12[1..dest_end]; +} +fn fn104() void { + dest_end = 1; + _ = src_ptr12[1..dest_end]; +} +fn fn105() void { + _ = src_ptr12[1..][0..2]; +} +fn fn106() void { + _ = src_ptr12[1..][0..3]; +} +fn fn107() void { + _ = src_ptr12[1..][0..1]; +} +fn fn108() void { + dest_len = 3; + _ = src_ptr12[1..][0..dest_len]; +} +fn fn109() void { + dest_len = 1; + _ = src_ptr12[1..][0..dest_len]; +} +fn fn110() void { + _ = src_ptr12[3..]; +} +fn fn111() void { + _ = src_ptr12[3..3]; +} +fn fn112() void { + dest_end = 3; + _ = src_ptr12[3..dest_end]; +} +fn fn113() void { + _ = src_ptr12[3..][0..2]; +} +fn fn114() void { + _ = src_ptr12[3..][0..3]; +} +fn fn115() void { + _ = src_ptr12[3..][0..1]; +} +fn fn116() void { + dest_len = 3; + _ = src_ptr12[3..][0..dest_len]; +} +fn fn117() void { + dest_len = 1; + _ = src_ptr12[3..][0..dest_len]; +} +var src_mem9: [2]u8 = .{ 0, 0 }; +const src_ptr13: *[2]u8 = src_mem9[0..2]; +fn fn118() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[0..dest_end]; +} +fn fn119() void { + dest_len = 3; + _ = src_ptr13[0..][0..dest_len]; +} +fn fn120() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr13[1..dest_end]; +} +fn fn121() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[1..][0..dest_len]; +} +fn fn122() void { + expect_id = .mismatched_sentinel; + _ = src_ptr13[0..1 :1]; +} +fn fn123() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[0..dest_end :1]; +} +fn fn124() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr13[0..dest_end :1]; +} +fn fn125() void { + _ = src_ptr13[0..][0..1 :1]; +} +fn fn126() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[0..][0..dest_len :1]; +} +fn fn127() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr13[0..][0..dest_len :1]; +} +fn fn128() void { + _ = src_ptr13[1..1 :1]; +} +fn fn129() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr13[1..dest_end :1]; +} +fn fn130() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr13[1..dest_end :1]; +} +fn fn131() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr13[1..][0..dest_len :1]; +} +fn fn132() void { + dest_len = 1; + _ = src_ptr13[1..][0..dest_len :1]; +} +var src_mem10: [2]u8 = .{ 0, 0 }; +const src_ptr14: *[1:0]u8 = src_mem10[0..1 :0]; +fn fn133() void { + dest_end = 3; + _ = src_ptr14[0..dest_end]; +} +fn fn134() void { + dest_len = 3; + _ = src_ptr14[0..][0..dest_len]; +} +fn fn135() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr14[1..dest_end]; +} +fn fn136() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr14[1..][0..dest_len]; +} +fn fn137() void { + expect_id = .mismatched_sentinel; + _ = src_ptr14[0.. :1]; +} +fn fn138() void { + _ = src_ptr14[0..1 :1]; +} +fn fn139() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr14[0..dest_end :1]; +} +fn fn140() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr14[0..dest_end :1]; +} +fn fn141() void { + _ = src_ptr14[0..][0..1 :1]; +} +fn fn142() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr14[0..][0..dest_len :1]; +} +fn fn143() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr14[0..][0..dest_len :1]; +} +fn fn144() void { + _ = src_ptr14[1.. :1]; +} +fn fn145() void { + _ = src_ptr14[1..1 :1]; +} +fn fn146() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr14[1..dest_end :1]; +} +fn fn147() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr14[1..dest_end :1]; +} +fn fn148() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr14[1..][0..dest_len :1]; +} +fn fn149() void { + dest_len = 1; + _ = src_ptr14[1..][0..dest_len :1]; +} +fn fn150() void { + dest_end = 3; + _ = src_ptr13[0..dest_end]; +} +fn fn151() void { + dest_len = 3; + _ = src_ptr13[0..][0..dest_len]; +} +fn fn152() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr13[1..dest_end]; +} +fn fn153() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[1..][0..dest_len]; +} +fn fn154() void { + expect_id = .mismatched_sentinel; + _ = src_ptr13[0..1 :1]; +} +fn fn155() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[0..dest_end :1]; +} +fn fn156() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr13[0..dest_end :1]; +} +fn fn157() void { + _ = src_ptr13[0..][0..1 :1]; +} +fn fn158() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr13[0..][0..dest_len :1]; +} +fn fn159() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr13[0..][0..dest_len :1]; +} +fn fn160() void { + _ = src_ptr13[1..1 :1]; +} +fn fn161() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr13[1..dest_end :1]; +} +fn fn162() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr13[1..dest_end :1]; +} +fn fn163() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr13[1..][0..dest_len :1]; +} +fn fn164() void { + dest_len = 1; + _ = src_ptr13[1..][0..dest_len :1]; +} +var src_mem11: [3]u8 = .{ 0, 0, 0 }; +const src_ptr15: *[3]u8 = src_mem11[0..3]; +fn fn165() void { + dest_len = 3; + _ = src_ptr15[1..][0..dest_len]; +} +fn fn166() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr15[3..dest_end]; +} +fn fn167() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr15[3..][0..dest_len]; +} +fn fn168() void { + dest_len = 1; + _ = src_ptr15[3..][0..dest_len]; +} +fn fn169() void { + expect_id = .mismatched_sentinel; + _ = src_ptr15[0..2 :1]; +} +fn fn170() void { + _ = src_ptr15[0..1 :1]; +} +fn fn171() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr15[0..dest_end :1]; +} +fn fn172() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr15[0..dest_end :1]; +} +fn fn173() void { + _ = src_ptr15[0..][0..2 :1]; +} +fn fn174() void { + _ = src_ptr15[0..][0..1 :1]; +} +fn fn175() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr15[0..][0..dest_len :1]; +} +fn fn176() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr15[0..][0..dest_len :1]; +} +fn fn177() void { + _ = src_ptr15[1..2 :1]; +} +fn fn178() void { + _ = src_ptr15[1..1 :1]; +} +fn fn179() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr15[1..dest_end :1]; +} +fn fn180() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr15[1..dest_end :1]; +} +fn fn181() void { + _ = src_ptr15[1..][0..1 :1]; +} +fn fn182() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr15[1..][0..dest_len :1]; +} +fn fn183() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr15[1..][0..dest_len :1]; +} +var src_mem12: [3]u8 = .{ 0, 0, 0 }; +const src_ptr16: *[2:0]u8 = src_mem12[0..2 :0]; +fn fn184() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr16[1..][0..dest_len]; +} +fn fn185() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr16[3..dest_end]; +} +fn fn186() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr16[3..][0..dest_len]; +} +fn fn187() void { + dest_len = 1; + _ = src_ptr16[3..][0..dest_len]; +} +fn fn188() void { + expect_id = .mismatched_sentinel; + _ = src_ptr16[0.. :1]; +} +fn fn189() void { + _ = src_ptr16[0..2 :1]; +} +fn fn190() void { + _ = src_ptr16[0..1 :1]; +} +fn fn191() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr16[0..dest_end :1]; +} +fn fn192() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr16[0..dest_end :1]; +} +fn fn193() void { + _ = src_ptr16[0..][0..2 :1]; +} +fn fn194() void { + _ = src_ptr16[0..][0..1 :1]; +} +fn fn195() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr16[0..][0..dest_len :1]; +} +fn fn196() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr16[0..][0..dest_len :1]; +} +fn fn197() void { + _ = src_ptr16[1.. :1]; +} +fn fn198() void { + _ = src_ptr16[1..2 :1]; +} +fn fn199() void { + _ = src_ptr16[1..1 :1]; +} +fn fn200() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr16[1..dest_end :1]; +} +fn fn201() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr16[1..dest_end :1]; +} +fn fn202() void { + _ = src_ptr16[1..][0..1 :1]; +} +fn fn203() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr16[1..][0..dest_len :1]; +} +fn fn204() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr16[1..][0..dest_len :1]; +} +fn fn205() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr15[1..][0..dest_len]; +} +fn fn206() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr15[3..dest_end]; +} +fn fn207() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr15[3..][0..dest_len]; +} +fn fn208() void { + dest_len = 1; + _ = src_ptr15[3..][0..dest_len]; +} +fn fn209() void { + expect_id = .mismatched_sentinel; + _ = src_ptr15[0..2 :1]; +} +fn fn210() void { + _ = src_ptr15[0..1 :1]; +} +fn fn211() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr15[0..dest_end :1]; +} +fn fn212() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr15[0..dest_end :1]; +} +fn fn213() void { + _ = src_ptr15[0..][0..2 :1]; +} +fn fn214() void { + _ = src_ptr15[0..][0..1 :1]; +} +fn fn215() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr15[0..][0..dest_len :1]; +} +fn fn216() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr15[0..][0..dest_len :1]; +} +fn fn217() void { + _ = src_ptr15[1..2 :1]; +} +fn fn218() void { + _ = src_ptr15[1..1 :1]; +} +fn fn219() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr15[1..dest_end :1]; +} +fn fn220() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr15[1..dest_end :1]; +} +fn fn221() void { + _ = src_ptr15[1..][0..1 :1]; +} +fn fn222() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr15[1..][0..dest_len :1]; +} +fn fn223() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr15[1..][0..dest_len :1]; +} +var src_mem13: [1]u8 = .{0}; +const src_ptr17: *[1]u8 = src_mem13[0..1]; +fn fn224() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr17[0..dest_end]; +} +fn fn225() void { + dest_len = 3; + _ = src_ptr17[0..][0..dest_len]; +} +fn fn226() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr17[1..dest_end]; +} +fn fn227() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr17[1..][0..dest_len]; +} +fn fn228() void { + dest_len = 1; + _ = src_ptr17[1..][0..dest_len]; +} +fn fn229() void { + _ = src_ptr17[0..dest_end :1]; +} +fn fn230() void { + dest_end = 1; + _ = src_ptr17[0..dest_end :1]; +} +fn fn231() void { + dest_len = 3; + _ = src_ptr17[0..][0..dest_len :1]; +} +fn fn232() void { + dest_len = 1; + _ = src_ptr17[0..][0..dest_len :1]; +} +var src_mem14: [1]u8 = .{0}; +const src_ptr18: *[0:0]u8 = src_mem14[0..0 :0]; +fn fn233() void { + dest_end = 3; + _ = src_ptr18[0..dest_end]; +} +fn fn234() void { + dest_len = 3; + _ = src_ptr18[0..][0..dest_len]; +} +fn fn235() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr18[1..dest_end]; +} +fn fn236() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr18[1..][0..dest_len]; +} +fn fn237() void { + dest_len = 1; + _ = src_ptr18[1..][0..dest_len]; +} +fn fn238() void { + expect_id = .mismatched_sentinel; + _ = src_ptr18[0.. :1]; +} +fn fn239() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr18[0..dest_end :1]; +} +fn fn240() void { + dest_end = 1; + _ = src_ptr18[0..dest_end :1]; +} +fn fn241() void { + dest_len = 3; + _ = src_ptr18[0..][0..dest_len :1]; +} +fn fn242() void { + dest_len = 1; + _ = src_ptr18[0..][0..dest_len :1]; +} +fn fn243() void { + dest_end = 3; + _ = src_ptr17[0..dest_end]; +} +fn fn244() void { + dest_len = 3; + _ = src_ptr17[0..][0..dest_len]; +} +fn fn245() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr17[1..dest_end]; +} +fn fn246() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr17[1..][0..dest_len]; +} +fn fn247() void { + dest_len = 1; + _ = src_ptr17[1..][0..dest_len]; +} +fn fn248() void { + _ = src_ptr17[0..dest_end :1]; +} +fn fn249() void { + dest_end = 1; + _ = src_ptr17[0..dest_end :1]; +} +fn fn250() void { + dest_len = 3; + _ = src_ptr17[0..][0..dest_len :1]; +} +fn fn251() void { + dest_len = 1; + _ = src_ptr17[0..][0..dest_len :1]; +} +var src_mem15: [2]u8 = .{ 0, 0 }; +var src_ptr19: *[2]u8 = src_mem15[0..2]; +fn fn252() void { + dest_end = 3; + _ = src_ptr19[0..dest_end]; +} +fn fn253() void { + dest_len = 3; + _ = src_ptr19[0..][0..dest_len]; +} +fn fn254() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr19[1..dest_end]; +} +fn fn255() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr19[1..][0..dest_len]; +} +fn fn256() void { + expect_id = .mismatched_sentinel; + _ = src_ptr19[0..1 :1]; +} +fn fn257() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr19[0..dest_end :1]; +} +fn fn258() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr19[0..dest_end :1]; +} +fn fn259() void { + _ = src_ptr19[0..][0..1 :1]; +} +fn fn260() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr19[0..][0..dest_len :1]; +} +fn fn261() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr19[0..][0..dest_len :1]; +} +fn fn262() void { + _ = src_ptr19[1..1 :1]; +} +fn fn263() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr19[1..dest_end :1]; +} +fn fn264() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr19[1..dest_end :1]; +} +fn fn265() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr19[1..][0..dest_len :1]; +} +fn fn266() void { + dest_len = 1; + _ = src_ptr19[1..][0..dest_len :1]; +} +var src_mem16: [2]u8 = .{ 0, 0 }; +var src_ptr20: *[1:0]u8 = src_mem16[0..1 :0]; +fn fn267() void { + dest_end = 3; + _ = src_ptr20[0..dest_end]; +} +fn fn268() void { + dest_len = 3; + _ = src_ptr20[0..][0..dest_len]; +} +fn fn269() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr20[1..dest_end]; +} +fn fn270() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr20[1..][0..dest_len]; +} +fn fn271() void { + expect_id = .mismatched_sentinel; + _ = src_ptr20[0.. :1]; +} +fn fn272() void { + _ = src_ptr20[0..1 :1]; +} +fn fn273() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr20[0..dest_end :1]; +} +fn fn274() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr20[0..dest_end :1]; +} +fn fn275() void { + _ = src_ptr20[0..][0..1 :1]; +} +fn fn276() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr20[0..][0..dest_len :1]; +} +fn fn277() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr20[0..][0..dest_len :1]; +} +fn fn278() void { + _ = src_ptr20[1.. :1]; +} +fn fn279() void { + _ = src_ptr20[1..1 :1]; +} +fn fn280() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr20[1..dest_end :1]; +} +fn fn281() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr20[1..dest_end :1]; +} +fn fn282() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr20[1..][0..dest_len :1]; +} +fn fn283() void { + dest_len = 1; + _ = src_ptr20[1..][0..dest_len :1]; +} +var src_mem17: [3]u8 = .{ 0, 0, 0 }; +var src_ptr21: *[3]u8 = src_mem17[0..3]; +fn fn284() void { + dest_len = 3; + _ = src_ptr21[1..][0..dest_len]; +} +fn fn285() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr21[3..dest_end]; +} +fn fn286() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr21[3..][0..dest_len]; +} +fn fn287() void { + dest_len = 1; + _ = src_ptr21[3..][0..dest_len]; +} +fn fn288() void { + expect_id = .mismatched_sentinel; + _ = src_ptr21[0..2 :1]; +} +fn fn289() void { + _ = src_ptr21[0..1 :1]; +} +fn fn290() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr21[0..dest_end :1]; +} +fn fn291() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr21[0..dest_end :1]; +} +fn fn292() void { + _ = src_ptr21[0..][0..2 :1]; +} +fn fn293() void { + _ = src_ptr21[0..][0..1 :1]; +} +fn fn294() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr21[0..][0..dest_len :1]; +} +fn fn295() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr21[0..][0..dest_len :1]; +} +fn fn296() void { + _ = src_ptr21[1..2 :1]; +} +fn fn297() void { + _ = src_ptr21[1..1 :1]; +} +fn fn298() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr21[1..dest_end :1]; +} +fn fn299() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr21[1..dest_end :1]; +} +fn fn300() void { + _ = src_ptr21[1..][0..1 :1]; +} +fn fn301() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr21[1..][0..dest_len :1]; +} +fn fn302() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr21[1..][0..dest_len :1]; +} +var src_mem18: [3]u8 = .{ 0, 0, 0 }; +var src_ptr22: *[2:0]u8 = src_mem18[0..2 :0]; +fn fn303() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr22[1..][0..dest_len]; +} +fn fn304() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr22[3..dest_end]; +} +fn fn305() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr22[3..][0..dest_len]; +} +fn fn306() void { + dest_len = 1; + _ = src_ptr22[3..][0..dest_len]; +} +fn fn307() void { + expect_id = .mismatched_sentinel; + _ = src_ptr22[0.. :1]; +} +fn fn308() void { + _ = src_ptr22[0..2 :1]; +} +fn fn309() void { + _ = src_ptr22[0..1 :1]; +} +fn fn310() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr22[0..dest_end :1]; +} +fn fn311() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr22[0..dest_end :1]; +} +fn fn312() void { + _ = src_ptr22[0..][0..2 :1]; +} +fn fn313() void { + _ = src_ptr22[0..][0..1 :1]; +} +fn fn314() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr22[0..][0..dest_len :1]; +} +fn fn315() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr22[0..][0..dest_len :1]; +} +fn fn316() void { + _ = src_ptr22[1.. :1]; +} +fn fn317() void { + _ = src_ptr22[1..2 :1]; +} +fn fn318() void { + _ = src_ptr22[1..1 :1]; +} +fn fn319() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr22[1..dest_end :1]; +} +fn fn320() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr22[1..dest_end :1]; +} +fn fn321() void { + _ = src_ptr22[1..][0..1 :1]; +} +fn fn322() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr22[1..][0..dest_len :1]; +} +fn fn323() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr22[1..][0..dest_len :1]; +} +var src_mem19: [1]u8 = .{0}; +var src_ptr23: *[1]u8 = src_mem19[0..1]; +fn fn324() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr23[0..dest_end]; +} +fn fn325() void { + dest_len = 3; + _ = src_ptr23[0..][0..dest_len]; +} +fn fn326() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr23[1..dest_end]; +} +fn fn327() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr23[1..][0..dest_len]; +} +fn fn328() void { + dest_len = 1; + _ = src_ptr23[1..][0..dest_len]; +} +fn fn329() void { + _ = src_ptr23[0..dest_end :1]; +} +fn fn330() void { + dest_end = 1; + _ = src_ptr23[0..dest_end :1]; +} +fn fn331() void { + dest_len = 3; + _ = src_ptr23[0..][0..dest_len :1]; +} +fn fn332() void { + dest_len = 1; + _ = src_ptr23[0..][0..dest_len :1]; +} +var src_mem20: [1]u8 = .{0}; +var src_ptr24: *[0:0]u8 = src_mem20[0..0 :0]; +fn fn333() void { + dest_end = 3; + _ = src_ptr24[0..dest_end]; +} +fn fn334() void { + dest_len = 3; + _ = src_ptr24[0..][0..dest_len]; +} +fn fn335() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr24[1..dest_end]; +} +fn fn336() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr24[1..][0..dest_len]; +} +fn fn337() void { + dest_len = 1; + _ = src_ptr24[1..][0..dest_len]; +} +fn fn338() void { + expect_id = .mismatched_sentinel; + _ = src_ptr24[0.. :1]; +} +fn fn339() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr24[0..dest_end :1]; +} +fn fn340() void { + dest_end = 1; + _ = src_ptr24[0..dest_end :1]; +} +fn fn341() void { + dest_len = 3; + _ = src_ptr24[0..][0..dest_len :1]; +} +fn fn342() void { + dest_len = 1; + _ = src_ptr24[0..][0..dest_len :1]; +} +const src_ptr25: []u8 = src_mem9[0..2]; +fn fn343() void { + dest_end = 3; + _ = src_ptr25[0..dest_end]; +} +fn fn344() void { + dest_len = 3; + _ = src_ptr25[0..][0..dest_len]; +} +fn fn345() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr25[1..dest_end]; +} +fn fn346() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr25[1..][0..dest_len]; +} +fn fn347() void { + expect_id = .mismatched_sentinel; + _ = src_ptr25[0..1 :1]; +} +fn fn348() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr25[0..dest_end :1]; +} +fn fn349() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr25[0..dest_end :1]; +} +fn fn350() void { + _ = src_ptr25[0..][0..1 :1]; +} +fn fn351() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr25[0..][0..dest_len :1]; +} +fn fn352() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr25[0..][0..dest_len :1]; +} +fn fn353() void { + _ = src_ptr25[1..1 :1]; +} +fn fn354() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr25[1..dest_end :1]; +} +fn fn355() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr25[1..dest_end :1]; +} +fn fn356() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr25[1..][0..dest_len :1]; +} +fn fn357() void { + dest_len = 1; + _ = src_ptr25[1..][0..dest_len :1]; +} +const src_ptr26: [:0]u8 = src_mem10[0..1 :0]; +fn fn358() void { + dest_end = 3; + _ = src_ptr26[0..dest_end]; +} +fn fn359() void { + dest_len = 3; + _ = src_ptr26[0..][0..dest_len]; +} +fn fn360() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr26[1..dest_end]; +} +fn fn361() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr26[1..][0..dest_len]; +} +fn fn362() void { + expect_id = .mismatched_sentinel; + _ = src_ptr26[0.. :1]; +} +fn fn363() void { + _ = src_ptr26[0..1 :1]; +} +fn fn364() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr26[0..dest_end :1]; +} +fn fn365() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr26[0..dest_end :1]; +} +fn fn366() void { + _ = src_ptr26[0..][0..1 :1]; +} +fn fn367() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr26[0..][0..dest_len :1]; +} +fn fn368() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr26[0..][0..dest_len :1]; +} +fn fn369() void { + _ = src_ptr26[1.. :1]; +} +fn fn370() void { + _ = src_ptr26[1..1 :1]; +} +fn fn371() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr26[1..dest_end :1]; +} +fn fn372() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr26[1..dest_end :1]; +} +fn fn373() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr26[1..][0..dest_len :1]; +} +fn fn374() void { + dest_len = 1; + _ = src_ptr26[1..][0..dest_len :1]; +} +const src_ptr27: []u8 = src_mem11[0..3]; +fn fn375() void { + dest_len = 3; + _ = src_ptr27[1..][0..dest_len]; +} +fn fn376() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr27[3..dest_end]; +} +fn fn377() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr27[3..][0..dest_len]; +} +fn fn378() void { + dest_len = 1; + _ = src_ptr27[3..][0..dest_len]; +} +fn fn379() void { + expect_id = .mismatched_sentinel; + _ = src_ptr27[0..2 :1]; +} +fn fn380() void { + _ = src_ptr27[0..1 :1]; +} +fn fn381() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr27[0..dest_end :1]; +} +fn fn382() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr27[0..dest_end :1]; +} +fn fn383() void { + _ = src_ptr27[0..][0..2 :1]; +} +fn fn384() void { + _ = src_ptr27[0..][0..1 :1]; +} +fn fn385() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr27[0..][0..dest_len :1]; +} +fn fn386() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr27[0..][0..dest_len :1]; +} +fn fn387() void { + _ = src_ptr27[1..2 :1]; +} +fn fn388() void { + _ = src_ptr27[1..1 :1]; +} +fn fn389() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr27[1..dest_end :1]; +} +fn fn390() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr27[1..dest_end :1]; +} +fn fn391() void { + _ = src_ptr27[1..][0..1 :1]; +} +fn fn392() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr27[1..][0..dest_len :1]; +} +fn fn393() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr27[1..][0..dest_len :1]; +} +const src_ptr28: [:0]u8 = src_mem12[0..2 :0]; +fn fn394() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr28[1..][0..dest_len]; +} +fn fn395() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr28[3..dest_end]; +} +fn fn396() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr28[3..][0..dest_len]; +} +fn fn397() void { + dest_len = 1; + _ = src_ptr28[3..][0..dest_len]; +} +fn fn398() void { + expect_id = .mismatched_sentinel; + _ = src_ptr28[0.. :1]; +} +fn fn399() void { + _ = src_ptr28[0..2 :1]; +} +fn fn400() void { + _ = src_ptr28[0..1 :1]; +} +fn fn401() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr28[0..dest_end :1]; +} +fn fn402() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr28[0..dest_end :1]; +} +fn fn403() void { + _ = src_ptr28[0..][0..2 :1]; +} +fn fn404() void { + _ = src_ptr28[0..][0..1 :1]; +} +fn fn405() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr28[0..][0..dest_len :1]; +} +fn fn406() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr28[0..][0..dest_len :1]; +} +fn fn407() void { + _ = src_ptr28[1.. :1]; +} +fn fn408() void { + _ = src_ptr28[1..2 :1]; +} +fn fn409() void { + _ = src_ptr28[1..1 :1]; +} +fn fn410() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr28[1..dest_end :1]; +} +fn fn411() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr28[1..dest_end :1]; +} +fn fn412() void { + _ = src_ptr28[1..][0..1 :1]; +} +fn fn413() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr28[1..][0..dest_len :1]; +} +fn fn414() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr28[1..][0..dest_len :1]; +} +const src_ptr29: []u8 = src_mem13[0..1]; +fn fn415() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr29[0..dest_end]; +} +fn fn416() void { + dest_len = 3; + _ = src_ptr29[0..][0..dest_len]; +} +fn fn417() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr29[1..dest_end]; +} +fn fn418() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr29[1..][0..dest_len]; +} +fn fn419() void { + dest_len = 1; + _ = src_ptr29[1..][0..dest_len]; +} +fn fn420() void { + _ = src_ptr29[0..dest_end :1]; +} +fn fn421() void { + dest_end = 1; + _ = src_ptr29[0..dest_end :1]; +} +fn fn422() void { + dest_len = 3; + _ = src_ptr29[0..][0..dest_len :1]; +} +fn fn423() void { + dest_len = 1; + _ = src_ptr29[0..][0..dest_len :1]; +} +const src_ptr30: [:0]u8 = src_mem14[0..0 :0]; +fn fn424() void { + dest_end = 3; + _ = src_ptr30[0..dest_end]; +} +fn fn425() void { + dest_len = 3; + _ = src_ptr30[0..][0..dest_len]; +} +fn fn426() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr30[1..dest_end]; +} +fn fn427() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr30[1..][0..dest_len]; +} +fn fn428() void { + dest_len = 1; + _ = src_ptr30[1..][0..dest_len]; +} +fn fn429() void { + expect_id = .mismatched_sentinel; + _ = src_ptr30[0.. :1]; +} +fn fn430() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr30[0..dest_end :1]; +} +fn fn431() void { + dest_end = 1; + _ = src_ptr30[0..dest_end :1]; +} +fn fn432() void { + dest_len = 3; + _ = src_ptr30[0..][0..dest_len :1]; +} +fn fn433() void { + dest_len = 1; + _ = src_ptr30[0..][0..dest_len :1]; +} +var src_mem21: [2]u8 = .{ 0, 0 }; +var src_ptr31: []u8 = src_mem21[0..2]; +fn fn434() void { + _ = src_ptr31[0..3]; +} +fn fn435() void { + dest_end = 3; + _ = src_ptr31[0..dest_end]; +} +fn fn436() void { + _ = src_ptr31[0..][0..3]; +} +fn fn437() void { + dest_len = 3; + _ = src_ptr31[0..][0..dest_len]; +} +fn fn438() void { + _ = src_ptr31[1..3]; +} +fn fn439() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr31[1..dest_end]; +} +fn fn440() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[1..][0..2]; +} +fn fn441() void { + _ = src_ptr31[1..][0..3]; +} +fn fn442() void { + _ = src_ptr31[1..][0..dest_len]; +} +fn fn443() void { + expect_id = .accessed_out_of_order; + _ = src_ptr31[3..]; +} +fn fn444() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[3..3]; +} +fn fn445() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr31[3..dest_end]; +} +fn fn446() void { + dest_end = 1; + _ = src_ptr31[3..dest_end]; +} +fn fn447() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[3..][0..2]; +} +fn fn448() void { + _ = src_ptr31[3..][0..3]; +} +fn fn449() void { + _ = src_ptr31[3..][0..1]; +} +fn fn450() void { + _ = src_ptr31[3..][0..dest_len]; +} +fn fn451() void { + dest_len = 1; + _ = src_ptr31[3..][0..dest_len]; +} +fn fn452() void { + _ = src_ptr31[0..2 :1]; +} +fn fn453() void { + _ = src_ptr31[0..3 :1]; +} +fn fn454() void { + expect_id = .mismatched_sentinel; + _ = src_ptr31[0..1 :1]; +} +fn fn455() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr31[0..dest_end :1]; +} +fn fn456() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr31[0..dest_end :1]; +} +fn fn457() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[0..][0..2 :1]; +} +fn fn458() void { + _ = src_ptr31[0..][0..3 :1]; +} +fn fn459() void { + expect_id = .mismatched_sentinel; + _ = src_ptr31[0..][0..1 :1]; +} +fn fn460() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr31[0..][0..dest_len :1]; +} +fn fn461() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr31[0..][0..dest_len :1]; +} +fn fn462() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[1..2 :1]; +} +fn fn463() void { + _ = src_ptr31[1..3 :1]; +} +fn fn464() void { + expect_id = .mismatched_sentinel; + _ = src_ptr31[1..1 :1]; +} +fn fn465() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr31[1..dest_end :1]; +} +fn fn466() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr31[1..dest_end :1]; +} +fn fn467() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[1..][0..2 :1]; +} +fn fn468() void { + _ = src_ptr31[1..][0..3 :1]; +} +fn fn469() void { + _ = src_ptr31[1..][0..1 :1]; +} +fn fn470() void { + dest_len = 3; + _ = src_ptr31[1..][0..dest_len :1]; +} +fn fn471() void { + dest_len = 1; + _ = src_ptr31[1..][0..dest_len :1]; +} +fn fn472() void { + _ = src_ptr31[3..3 :1]; +} +fn fn473() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr31[3..dest_end :1]; +} +fn fn474() void { + dest_end = 1; + _ = src_ptr31[3..dest_end :1]; +} +fn fn475() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr31[3..][0..2 :1]; +} +fn fn476() void { + _ = src_ptr31[3..][0..3 :1]; +} +fn fn477() void { + _ = src_ptr31[3..][0..1 :1]; +} +fn fn478() void { + dest_len = 3; + _ = src_ptr31[3..][0..dest_len :1]; +} +fn fn479() void { + dest_len = 1; + _ = src_ptr31[3..][0..dest_len :1]; +} +var src_mem22: [2]u8 = .{ 0, 0 }; +var src_ptr32: [:0]u8 = src_mem22[0..1 :0]; +fn fn480() void { + _ = src_ptr32[0..3]; +} +fn fn481() void { + dest_end = 3; + _ = src_ptr32[0..dest_end]; +} +fn fn482() void { + _ = src_ptr32[0..][0..3]; +} +fn fn483() void { + dest_len = 3; + _ = src_ptr32[0..][0..dest_len]; +} +fn fn484() void { + _ = src_ptr32[1..3]; +} +fn fn485() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr32[1..dest_end]; +} +fn fn486() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[1..][0..2]; +} +fn fn487() void { + _ = src_ptr32[1..][0..3]; +} +fn fn488() void { + _ = src_ptr32[1..][0..dest_len]; +} +fn fn489() void { + expect_id = .accessed_out_of_order; + _ = src_ptr32[3..]; +} +fn fn490() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[3..3]; +} +fn fn491() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr32[3..dest_end]; +} +fn fn492() void { + dest_end = 1; + _ = src_ptr32[3..dest_end]; +} +fn fn493() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[3..][0..2]; +} +fn fn494() void { + _ = src_ptr32[3..][0..3]; +} +fn fn495() void { + _ = src_ptr32[3..][0..1]; +} +fn fn496() void { + _ = src_ptr32[3..][0..dest_len]; +} +fn fn497() void { + dest_len = 1; + _ = src_ptr32[3..][0..dest_len]; +} +fn fn498() void { + expect_id = .mismatched_sentinel; + _ = src_ptr32[0.. :1]; +} +fn fn499() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[0..2 :1]; +} +fn fn500() void { + _ = src_ptr32[0..3 :1]; +} +fn fn501() void { + expect_id = .mismatched_sentinel; + _ = src_ptr32[0..1 :1]; +} +fn fn502() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr32[0..dest_end :1]; +} +fn fn503() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr32[0..dest_end :1]; +} +fn fn504() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[0..][0..2 :1]; +} +fn fn505() void { + _ = src_ptr32[0..][0..3 :1]; +} +fn fn506() void { + expect_id = .mismatched_sentinel; + _ = src_ptr32[0..][0..1 :1]; +} +fn fn507() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr32[0..][0..dest_len :1]; +} +fn fn508() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr32[0..][0..dest_len :1]; +} +fn fn509() void { + _ = src_ptr32[1.. :1]; +} +fn fn510() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[1..2 :1]; +} +fn fn511() void { + _ = src_ptr32[1..3 :1]; +} +fn fn512() void { + expect_id = .mismatched_sentinel; + _ = src_ptr32[1..1 :1]; +} +fn fn513() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr32[1..dest_end :1]; +} +fn fn514() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr32[1..dest_end :1]; +} +fn fn515() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[1..][0..2 :1]; +} +fn fn516() void { + _ = src_ptr32[1..][0..3 :1]; +} +fn fn517() void { + _ = src_ptr32[1..][0..1 :1]; +} +fn fn518() void { + dest_len = 3; + _ = src_ptr32[1..][0..dest_len :1]; +} +fn fn519() void { + dest_len = 1; + _ = src_ptr32[1..][0..dest_len :1]; +} +fn fn520() void { + expect_id = .accessed_out_of_order; + _ = src_ptr32[3.. :1]; +} +fn fn521() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[3..3 :1]; +} +fn fn522() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr32[3..dest_end :1]; +} +fn fn523() void { + dest_end = 1; + _ = src_ptr32[3..dest_end :1]; +} +fn fn524() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr32[3..][0..2 :1]; +} +fn fn525() void { + _ = src_ptr32[3..][0..3 :1]; +} +fn fn526() void { + _ = src_ptr32[3..][0..1 :1]; +} +fn fn527() void { + dest_len = 3; + _ = src_ptr32[3..][0..dest_len :1]; +} +fn fn528() void { + dest_len = 1; + _ = src_ptr32[3..][0..dest_len :1]; +} +var src_mem23: [3]u8 = .{ 0, 0, 0 }; +var src_ptr33: []u8 = src_mem23[0..3]; +fn fn529() void { + _ = src_ptr33[1..][0..3]; +} +fn fn530() void { + dest_len = 3; + _ = src_ptr33[1..][0..dest_len]; +} +fn fn531() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr33[3..dest_end]; +} +fn fn532() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[3..][0..2]; +} +fn fn533() void { + _ = src_ptr33[3..][0..3]; +} +fn fn534() void { + _ = src_ptr33[3..][0..1]; +} +fn fn535() void { + _ = src_ptr33[3..][0..dest_len]; +} +fn fn536() void { + dest_len = 1; + _ = src_ptr33[3..][0..dest_len]; +} +fn fn537() void { + expect_id = .mismatched_sentinel; + _ = src_ptr33[0..2 :1]; +} +fn fn538() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[0..3 :1]; +} +fn fn539() void { + expect_id = .mismatched_sentinel; + _ = src_ptr33[0..1 :1]; +} +fn fn540() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr33[0..dest_end :1]; +} +fn fn541() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr33[0..dest_end :1]; +} +fn fn542() void { + _ = src_ptr33[0..][0..2 :1]; +} +fn fn543() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[0..][0..3 :1]; +} +fn fn544() void { + expect_id = .mismatched_sentinel; + _ = src_ptr33[0..][0..1 :1]; +} +fn fn545() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr33[0..][0..dest_len :1]; +} +fn fn546() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr33[0..][0..dest_len :1]; +} +fn fn547() void { + _ = src_ptr33[1..2 :1]; +} +fn fn548() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[1..3 :1]; +} +fn fn549() void { + expect_id = .mismatched_sentinel; + _ = src_ptr33[1..1 :1]; +} +fn fn550() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr33[1..dest_end :1]; +} +fn fn551() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr33[1..dest_end :1]; +} +fn fn552() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[1..][0..2 :1]; +} +fn fn553() void { + _ = src_ptr33[1..][0..3 :1]; +} +fn fn554() void { + expect_id = .mismatched_sentinel; + _ = src_ptr33[1..][0..1 :1]; +} +fn fn555() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr33[1..][0..dest_len :1]; +} +fn fn556() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr33[1..][0..dest_len :1]; +} +fn fn557() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[3..3 :1]; +} +fn fn558() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr33[3..dest_end :1]; +} +fn fn559() void { + dest_end = 1; + _ = src_ptr33[3..dest_end :1]; +} +fn fn560() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr33[3..][0..2 :1]; +} +fn fn561() void { + _ = src_ptr33[3..][0..3 :1]; +} +fn fn562() void { + _ = src_ptr33[3..][0..1 :1]; +} +fn fn563() void { + dest_len = 3; + _ = src_ptr33[3..][0..dest_len :1]; +} +fn fn564() void { + dest_len = 1; + _ = src_ptr33[3..][0..dest_len :1]; +} +var src_mem24: [3]u8 = .{ 0, 0, 0 }; +var src_ptr34: [:0]u8 = src_mem24[0..2 :0]; +fn fn565() void { + _ = src_ptr34[1..][0..3]; +} +fn fn566() void { + dest_len = 3; + _ = src_ptr34[1..][0..dest_len]; +} +fn fn567() void { + expect_id = .accessed_out_of_order; + _ = src_ptr34[3..]; +} +fn fn568() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr34[3..dest_end]; +} +fn fn569() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[3..][0..2]; +} +fn fn570() void { + _ = src_ptr34[3..][0..3]; +} +fn fn571() void { + _ = src_ptr34[3..][0..1]; +} +fn fn572() void { + _ = src_ptr34[3..][0..dest_len]; +} +fn fn573() void { + dest_len = 1; + _ = src_ptr34[3..][0..dest_len]; +} +fn fn574() void { + expect_id = .mismatched_sentinel; + _ = src_ptr34[0.. :1]; +} +fn fn575() void { + _ = src_ptr34[0..2 :1]; +} +fn fn576() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[0..3 :1]; +} +fn fn577() void { + expect_id = .mismatched_sentinel; + _ = src_ptr34[0..1 :1]; +} +fn fn578() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr34[0..dest_end :1]; +} +fn fn579() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr34[0..dest_end :1]; +} +fn fn580() void { + _ = src_ptr34[0..][0..2 :1]; +} +fn fn581() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[0..][0..3 :1]; +} +fn fn582() void { + expect_id = .mismatched_sentinel; + _ = src_ptr34[0..][0..1 :1]; +} +fn fn583() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr34[0..][0..dest_len :1]; +} +fn fn584() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr34[0..][0..dest_len :1]; +} +fn fn585() void { + _ = src_ptr34[1.. :1]; +} +fn fn586() void { + _ = src_ptr34[1..2 :1]; +} +fn fn587() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[1..3 :1]; +} +fn fn588() void { + expect_id = .mismatched_sentinel; + _ = src_ptr34[1..1 :1]; +} +fn fn589() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr34[1..dest_end :1]; +} +fn fn590() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr34[1..dest_end :1]; +} +fn fn591() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[1..][0..2 :1]; +} +fn fn592() void { + _ = src_ptr34[1..][0..3 :1]; +} +fn fn593() void { + expect_id = .mismatched_sentinel; + _ = src_ptr34[1..][0..1 :1]; +} +fn fn594() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr34[1..][0..dest_len :1]; +} +fn fn595() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr34[1..][0..dest_len :1]; +} +fn fn596() void { + expect_id = .accessed_out_of_order; + _ = src_ptr34[3.. :1]; +} +fn fn597() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[3..3 :1]; +} +fn fn598() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr34[3..dest_end :1]; +} +fn fn599() void { + dest_end = 1; + _ = src_ptr34[3..dest_end :1]; +} +fn fn600() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr34[3..][0..2 :1]; +} +fn fn601() void { + _ = src_ptr34[3..][0..3 :1]; +} +fn fn602() void { + _ = src_ptr34[3..][0..1 :1]; +} +fn fn603() void { + dest_len = 3; + _ = src_ptr34[3..][0..dest_len :1]; +} +fn fn604() void { + dest_len = 1; + _ = src_ptr34[3..][0..dest_len :1]; +} +var src_mem25: [1]u8 = .{0}; +var src_ptr35: []u8 = src_mem25[0..1]; +fn fn605() void { + _ = src_ptr35[0..2]; +} +fn fn606() void { + _ = src_ptr35[0..3]; +} +fn fn607() void { + dest_end = 3; + _ = src_ptr35[0..dest_end]; +} +fn fn608() void { + _ = src_ptr35[0..][0..2]; +} +fn fn609() void { + _ = src_ptr35[0..][0..3]; +} +fn fn610() void { + dest_len = 3; + _ = src_ptr35[0..][0..dest_len]; +} +fn fn611() void { + _ = src_ptr35[1..2]; +} +fn fn612() void { + _ = src_ptr35[1..3]; +} +fn fn613() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr35[1..dest_end]; +} +fn fn614() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr35[1..][0..2]; +} +fn fn615() void { + _ = src_ptr35[1..][0..3]; +} +fn fn616() void { + _ = src_ptr35[1..][0..1]; +} +fn fn617() void { + _ = src_ptr35[1..][0..dest_len]; +} +fn fn618() void { + dest_len = 1; + _ = src_ptr35[1..][0..dest_len]; +} +fn fn619() void { + expect_id = .accessed_out_of_order; + _ = src_ptr35[3..]; +} +fn fn620() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr35[3..3]; +} +fn fn621() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr35[3..dest_end]; +} +fn fn622() void { + dest_end = 1; + _ = src_ptr35[3..dest_end]; +} +fn fn623() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr35[3..][0..2]; +} +fn fn624() void { + _ = src_ptr35[3..][0..3]; +} +fn fn625() void { + _ = src_ptr35[3..][0..1]; +} +fn fn626() void { + dest_len = 3; + _ = src_ptr35[3..][0..dest_len]; +} +fn fn627() void { + dest_len = 1; + _ = src_ptr35[3..][0..dest_len]; +} +fn fn628() void { + _ = src_ptr35[0..2 :1]; +} +fn fn629() void { + _ = src_ptr35[0..3 :1]; +} +fn fn630() void { + _ = src_ptr35[0..1 :1]; +} +fn fn631() void { + dest_end = 3; + _ = src_ptr35[0..dest_end :1]; +} +fn fn632() void { + dest_end = 1; + _ = src_ptr35[0..dest_end :1]; +} +fn fn633() void { + _ = src_ptr35[0..][0..2 :1]; +} +fn fn634() void { + _ = src_ptr35[0..][0..3 :1]; +} +fn fn635() void { + _ = src_ptr35[0..][0..1 :1]; +} +fn fn636() void { + dest_len = 3; + _ = src_ptr35[0..][0..dest_len :1]; +} +fn fn637() void { + dest_len = 1; + _ = src_ptr35[0..][0..dest_len :1]; +} +fn fn638() void { + _ = src_ptr35[1..2 :1]; +} +fn fn639() void { + _ = src_ptr35[1..3 :1]; +} +fn fn640() void { + _ = src_ptr35[1..1 :1]; +} +fn fn641() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr35[1..dest_end :1]; +} +fn fn642() void { + dest_end = 1; + _ = src_ptr35[1..dest_end :1]; +} +fn fn643() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr35[1..][0..2 :1]; +} +fn fn644() void { + _ = src_ptr35[1..][0..3 :1]; +} +fn fn645() void { + _ = src_ptr35[1..][0..1 :1]; +} +fn fn646() void { + dest_len = 3; + _ = src_ptr35[1..][0..dest_len :1]; +} +fn fn647() void { + dest_len = 1; + _ = src_ptr35[1..][0..dest_len :1]; +} +fn fn648() void { + _ = src_ptr35[3..3 :1]; +} +fn fn649() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr35[3..dest_end :1]; +} +fn fn650() void { + dest_end = 1; + _ = src_ptr35[3..dest_end :1]; +} +fn fn651() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr35[3..][0..2 :1]; +} +fn fn652() void { + _ = src_ptr35[3..][0..3 :1]; +} +fn fn653() void { + _ = src_ptr35[3..][0..1 :1]; +} +fn fn654() void { + dest_len = 3; + _ = src_ptr35[3..][0..dest_len :1]; +} +fn fn655() void { + dest_len = 1; + _ = src_ptr35[3..][0..dest_len :1]; +} +var src_mem26: [1]u8 = .{0}; +var src_ptr36: [:0]u8 = src_mem26[0..0 :0]; +fn fn656() void { + _ = src_ptr36[0..2]; +} +fn fn657() void { + _ = src_ptr36[0..3]; +} +fn fn658() void { + dest_end = 3; + _ = src_ptr36[0..dest_end]; +} +fn fn659() void { + _ = src_ptr36[0..][0..2]; +} +fn fn660() void { + _ = src_ptr36[0..][0..3]; +} +fn fn661() void { + dest_len = 3; + _ = src_ptr36[0..][0..dest_len]; +} +fn fn662() void { + expect_id = .accessed_out_of_order; + _ = src_ptr36[1..]; +} +fn fn663() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[1..2]; +} +fn fn664() void { + _ = src_ptr36[1..3]; +} +fn fn665() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr36[1..dest_end]; +} +fn fn666() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[1..][0..2]; +} +fn fn667() void { + _ = src_ptr36[1..][0..3]; +} +fn fn668() void { + _ = src_ptr36[1..][0..1]; +} +fn fn669() void { + _ = src_ptr36[1..][0..dest_len]; +} +fn fn670() void { + dest_len = 1; + _ = src_ptr36[1..][0..dest_len]; +} +fn fn671() void { + expect_id = .accessed_out_of_order; + _ = src_ptr36[3..]; +} +fn fn672() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[3..3]; +} +fn fn673() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr36[3..dest_end]; +} +fn fn674() void { + dest_end = 1; + _ = src_ptr36[3..dest_end]; +} +fn fn675() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[3..][0..2]; +} +fn fn676() void { + _ = src_ptr36[3..][0..3]; +} +fn fn677() void { + _ = src_ptr36[3..][0..1]; +} +fn fn678() void { + dest_len = 3; + _ = src_ptr36[3..][0..dest_len]; +} +fn fn679() void { + dest_len = 1; + _ = src_ptr36[3..][0..dest_len]; +} +fn fn680() void { + expect_id = .mismatched_sentinel; + _ = src_ptr36[0.. :1]; +} +fn fn681() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[0..2 :1]; +} +fn fn682() void { + _ = src_ptr36[0..3 :1]; +} +fn fn683() void { + _ = src_ptr36[0..1 :1]; +} +fn fn684() void { + dest_end = 3; + _ = src_ptr36[0..dest_end :1]; +} +fn fn685() void { + dest_end = 1; + _ = src_ptr36[0..dest_end :1]; +} +fn fn686() void { + _ = src_ptr36[0..][0..2 :1]; +} +fn fn687() void { + _ = src_ptr36[0..][0..3 :1]; +} +fn fn688() void { + _ = src_ptr36[0..][0..1 :1]; +} +fn fn689() void { + dest_len = 3; + _ = src_ptr36[0..][0..dest_len :1]; +} +fn fn690() void { + dest_len = 1; + _ = src_ptr36[0..][0..dest_len :1]; +} +fn fn691() void { + expect_id = .accessed_out_of_order; + _ = src_ptr36[1.. :1]; +} +fn fn692() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[1..2 :1]; +} +fn fn693() void { + _ = src_ptr36[1..3 :1]; +} +fn fn694() void { + _ = src_ptr36[1..1 :1]; +} +fn fn695() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr36[1..dest_end :1]; +} +fn fn696() void { + dest_end = 1; + _ = src_ptr36[1..dest_end :1]; +} +fn fn697() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[1..][0..2 :1]; +} +fn fn698() void { + _ = src_ptr36[1..][0..3 :1]; +} +fn fn699() void { + _ = src_ptr36[1..][0..1 :1]; +} +fn fn700() void { + dest_len = 3; + _ = src_ptr36[1..][0..dest_len :1]; +} +fn fn701() void { + dest_len = 1; + _ = src_ptr36[1..][0..dest_len :1]; +} +fn fn702() void { + expect_id = .accessed_out_of_order; + _ = src_ptr36[3.. :1]; +} +fn fn703() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[3..3 :1]; +} +fn fn704() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr36[3..dest_end :1]; +} +fn fn705() void { + dest_end = 1; + _ = src_ptr36[3..dest_end :1]; +} +fn fn706() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr36[3..][0..2 :1]; +} +fn fn707() void { + _ = src_ptr36[3..][0..3 :1]; +} +fn fn708() void { + _ = src_ptr36[3..][0..1 :1]; +} +fn fn709() void { + dest_len = 3; + _ = src_ptr36[3..][0..dest_len :1]; +} +fn fn710() void { + dest_len = 1; + _ = src_ptr36[3..][0..dest_len :1]; +} +const src_ptr37: [*]u8 = @ptrCast(&src_mem9); +fn fn711() void { + expect_id = .mismatched_sentinel; + _ = src_ptr37[0..1 :1]; +} +fn fn712() void { + _ = src_ptr37[0..dest_end :1]; +} +fn fn713() void { + _ = src_ptr37[0..][0..1 :1]; +} +fn fn714() void { + _ = src_ptr37[0..][0..dest_len :1]; +} +fn fn715() void { + _ = src_ptr37[1..1 :1]; +} +fn fn716() void { + _ = src_ptr37[1..dest_end :1]; +} +const src_ptr38: [*:0]u8 = @ptrCast(&src_mem10); +fn fn717() void { + _ = src_ptr38[0..1 :1]; +} +fn fn718() void { + _ = src_ptr38[0..dest_end :1]; +} +fn fn719() void { + _ = src_ptr38[0..][0..1 :1]; +} +fn fn720() void { + _ = src_ptr38[0..][0..dest_len :1]; +} +fn fn721() void { + _ = src_ptr38[1..1 :1]; +} +fn fn722() void { + _ = src_ptr38[1..dest_end :1]; +} +const src_ptr39: [*]u8 = @ptrCast(&src_mem11); +fn fn723() void { + _ = src_ptr39[0..2 :1]; +} +fn fn724() void { + _ = src_ptr39[0..1 :1]; +} +fn fn725() void { + _ = src_ptr39[0..dest_end :1]; +} +fn fn726() void { + _ = src_ptr39[0..][0..2 :1]; +} +fn fn727() void { + _ = src_ptr39[0..][0..1 :1]; +} +fn fn728() void { + _ = src_ptr39[0..][0..dest_len :1]; +} +fn fn729() void { + _ = src_ptr39[1..2 :1]; +} +fn fn730() void { + _ = src_ptr39[1..1 :1]; +} +fn fn731() void { + _ = src_ptr39[1..dest_end :1]; +} +fn fn732() void { + _ = src_ptr39[1..][0..1 :1]; +} +fn fn733() void { + _ = src_ptr39[1..][0..dest_len :1]; +} +const src_ptr40: [*:0]u8 = @ptrCast(&src_mem12); +fn fn734() void { + _ = src_ptr40[0..2 :1]; +} +fn fn735() void { + _ = src_ptr40[0..1 :1]; +} +fn fn736() void { + _ = src_ptr40[0..dest_end :1]; +} +fn fn737() void { + _ = src_ptr40[0..][0..2 :1]; +} +fn fn738() void { + _ = src_ptr40[0..][0..1 :1]; +} +fn fn739() void { + _ = src_ptr40[0..][0..dest_len :1]; +} +fn fn740() void { + _ = src_ptr40[1..2 :1]; +} +fn fn741() void { + _ = src_ptr40[1..1 :1]; +} +fn fn742() void { + _ = src_ptr40[1..dest_end :1]; +} +fn fn743() void { + _ = src_ptr40[1..][0..1 :1]; +} +fn fn744() void { + _ = src_ptr40[1..][0..dest_len :1]; +} +var src_mem27: [2]u8 = .{ 0, 0 }; +var src_ptr41: [*]u8 = @ptrCast(&src_mem27); +fn fn745() void { + _ = src_ptr41[0..1 :1]; +} +fn fn746() void { + _ = src_ptr41[0..dest_end :1]; +} +fn fn747() void { + _ = src_ptr41[0..][0..1 :1]; +} +fn fn748() void { + _ = src_ptr41[0..][0..dest_len :1]; +} +fn fn749() void { + _ = src_ptr41[1..1 :1]; +} +fn fn750() void { + _ = src_ptr41[1..dest_end :1]; +} +var src_mem28: [2]u8 = .{ 0, 0 }; +var src_ptr42: [*:0]u8 = @ptrCast(&src_mem28); +fn fn751() void { + _ = src_ptr42[0..1 :1]; +} +fn fn752() void { + _ = src_ptr42[0..dest_end :1]; +} +fn fn753() void { + _ = src_ptr42[0..][0..1 :1]; +} +fn fn754() void { + _ = src_ptr42[0..][0..dest_len :1]; +} +fn fn755() void { + _ = src_ptr42[1..1 :1]; +} +fn fn756() void { + _ = src_ptr42[1..dest_end :1]; +} +var src_mem29: [3]u8 = .{ 0, 0, 0 }; +var src_ptr43: [*]u8 = @ptrCast(&src_mem29); +fn fn757() void { + _ = src_ptr43[0..2 :1]; +} +fn fn758() void { + _ = src_ptr43[0..1 :1]; +} +fn fn759() void { + _ = src_ptr43[0..dest_end :1]; +} +fn fn760() void { + _ = src_ptr43[0..][0..2 :1]; +} +fn fn761() void { + _ = src_ptr43[0..][0..1 :1]; +} +fn fn762() void { + _ = src_ptr43[0..][0..dest_len :1]; +} +fn fn763() void { + _ = src_ptr43[1..2 :1]; +} +fn fn764() void { + _ = src_ptr43[1..1 :1]; +} +fn fn765() void { + _ = src_ptr43[1..dest_end :1]; +} +fn fn766() void { + _ = src_ptr43[1..][0..1 :1]; +} +fn fn767() void { + _ = src_ptr43[1..][0..dest_len :1]; +} +var src_mem30: [3]u8 = .{ 0, 0, 0 }; +var src_ptr44: [*:0]u8 = @ptrCast(&src_mem30); +fn fn768() void { + _ = src_ptr44[0..2 :1]; +} +fn fn769() void { + _ = src_ptr44[0..1 :1]; +} +fn fn770() void { + _ = src_ptr44[0..dest_end :1]; +} +fn fn771() void { + _ = src_ptr44[0..][0..2 :1]; +} +fn fn772() void { + _ = src_ptr44[0..][0..1 :1]; +} +fn fn773() void { + _ = src_ptr44[0..][0..dest_len :1]; +} +fn fn774() void { + _ = src_ptr44[1..2 :1]; +} +fn fn775() void { + _ = src_ptr44[1..1 :1]; +} +fn fn776() void { + _ = src_ptr44[1..dest_end :1]; +} +fn fn777() void { + _ = src_ptr44[1..][0..1 :1]; +} +fn fn778() void { + _ = src_ptr44[1..][0..dest_len :1]; +} +var src_ptr45: [*c]u8 = null; +fn fn779() void { + expect_id = .accessed_null_value; + _ = src_ptr45[0..]; +} +fn fn780() void { + _ = src_ptr45[0..2]; +} +fn fn781() void { + _ = src_ptr45[0..3]; +} +fn fn782() void { + _ = src_ptr45[0..1]; +} +fn fn783() void { + dest_end = 3; + _ = src_ptr45[0..dest_end]; +} +fn fn784() void { + dest_end = 1; + _ = src_ptr45[0..dest_end]; +} +fn fn785() void { + _ = src_ptr45[0..][0..2]; +} +fn fn786() void { + _ = src_ptr45[0..][0..3]; +} +fn fn787() void { + _ = src_ptr45[0..][0..1]; +} +fn fn788() void { + dest_len = 3; + _ = src_ptr45[0..][0..dest_len]; +} +fn fn789() void { + dest_len = 1; + _ = src_ptr45[0..][0..dest_len]; +} +fn fn790() void { + _ = src_ptr45[1..]; +} +fn fn791() void { + _ = src_ptr45[1..2]; +} +fn fn792() void { + _ = src_ptr45[1..3]; +} +fn fn793() void { + _ = src_ptr45[1..1]; +} +fn fn794() void { + dest_end = 3; + _ = src_ptr45[1..dest_end]; +} +fn fn795() void { + dest_end = 1; + _ = src_ptr45[1..dest_end]; +} +fn fn796() void { + _ = src_ptr45[1..][0..2]; +} +fn fn797() void { + _ = src_ptr45[1..][0..3]; +} +fn fn798() void { + _ = src_ptr45[1..][0..1]; +} +fn fn799() void { + dest_len = 3; + _ = src_ptr45[1..][0..dest_len]; +} +fn fn800() void { + dest_len = 1; + _ = src_ptr45[1..][0..dest_len]; +} +fn fn801() void { + _ = src_ptr45[3..]; +} +fn fn802() void { + _ = src_ptr45[3..3]; +} +fn fn803() void { + dest_end = 3; + _ = src_ptr45[3..dest_end]; +} +fn fn804() void { + _ = src_ptr45[3..][0..2]; +} +fn fn805() void { + _ = src_ptr45[3..][0..3]; +} +fn fn806() void { + _ = src_ptr45[3..][0..1]; +} +fn fn807() void { + dest_len = 3; + _ = src_ptr45[3..][0..dest_len]; +} +fn fn808() void { + dest_len = 1; + _ = src_ptr45[3..][0..dest_len]; +} +fn fn809() void { + _ = src_ptr45[0.. :1]; +} +fn fn810() void { + _ = src_ptr45[0..2 :1]; +} +fn fn811() void { + _ = src_ptr45[0..3 :1]; +} +fn fn812() void { + _ = src_ptr45[0..1 :1]; +} +fn fn813() void { + _ = src_ptr45[0..dest_end :1]; +} +fn fn814() void { + dest_end = 1; + _ = src_ptr45[0..dest_end :1]; +} +fn fn815() void { + _ = src_ptr45[0..][0..2 :1]; +} +fn fn816() void { + _ = src_ptr45[0..][0..3 :1]; +} +fn fn817() void { + _ = src_ptr45[0..][0..1 :1]; +} +fn fn818() void { + dest_len = 3; + _ = src_ptr45[0..][0..dest_len :1]; +} +fn fn819() void { + dest_len = 1; + _ = src_ptr45[0..][0..dest_len :1]; +} +fn fn820() void { + _ = src_ptr45[1.. :1]; +} +fn fn821() void { + _ = src_ptr45[1..2 :1]; +} +fn fn822() void { + _ = src_ptr45[1..3 :1]; +} +fn fn823() void { + _ = src_ptr45[1..1 :1]; +} +fn fn824() void { + dest_end = 3; + _ = src_ptr45[1..dest_end :1]; +} +fn fn825() void { + dest_end = 1; + _ = src_ptr45[1..dest_end :1]; +} +fn fn826() void { + _ = src_ptr45[1..][0..2 :1]; +} +fn fn827() void { + _ = src_ptr45[1..][0..3 :1]; +} +fn fn828() void { + _ = src_ptr45[1..][0..1 :1]; +} +fn fn829() void { + dest_len = 3; + _ = src_ptr45[1..][0..dest_len :1]; +} +fn fn830() void { + dest_len = 1; + _ = src_ptr45[1..][0..dest_len :1]; +} +fn fn831() void { + _ = src_ptr45[3.. :1]; +} +fn fn832() void { + _ = src_ptr45[3..3 :1]; +} +fn fn833() void { + dest_end = 3; + _ = src_ptr45[3..dest_end :1]; +} +fn fn834() void { + _ = src_ptr45[3..][0..2 :1]; +} +fn fn835() void { + _ = src_ptr45[3..][0..3 :1]; +} +fn fn836() void { + _ = src_ptr45[3..][0..1 :1]; +} +fn fn837() void { + dest_len = 3; + _ = src_ptr45[3..][0..dest_len :1]; +} +fn fn838() void { + dest_len = 1; + _ = src_ptr45[3..][0..dest_len :1]; +} +const src_ptr46: [*c]u8 = @ptrCast(&src_mem9); +fn fn839() void { + expect_id = .mismatched_sentinel; + _ = src_ptr46[0..1 :1]; +} +fn fn840() void { + dest_end = 1; + _ = src_ptr46[0..dest_end :1]; +} +fn fn841() void { + _ = src_ptr46[0..][0..1 :1]; +} +fn fn842() void { + _ = src_ptr46[0..][0..dest_len :1]; +} +fn fn843() void { + _ = src_ptr46[1..1 :1]; +} +fn fn844() void { + _ = src_ptr46[1..dest_end :1]; +} +const src_ptr47: [*c]u8 = @ptrCast(&src_mem11); +fn fn845() void { + _ = src_ptr47[0..2 :1]; +} +fn fn846() void { + _ = src_ptr47[0..1 :1]; +} +fn fn847() void { + _ = src_ptr47[0..dest_end :1]; +} +fn fn848() void { + _ = src_ptr47[0..][0..2 :1]; +} +fn fn849() void { + _ = src_ptr47[0..][0..1 :1]; +} +fn fn850() void { + _ = src_ptr47[0..][0..dest_len :1]; +} +fn fn851() void { + _ = src_ptr47[1..2 :1]; +} +fn fn852() void { + _ = src_ptr47[1..1 :1]; +} +fn fn853() void { + _ = src_ptr47[1..dest_end :1]; +} +fn fn854() void { + _ = src_ptr47[1..][0..1 :1]; +} +fn fn855() void { + _ = src_ptr47[1..][0..dest_len :1]; +} +var src_mem31: [2]u8 = .{ 0, 0 }; +var src_ptr48: [*c]u8 = @ptrCast(&src_mem31); +fn fn856() void { + _ = src_ptr48[0..1 :1]; +} +fn fn857() void { + _ = src_ptr48[0..dest_end :1]; +} +fn fn858() void { + _ = src_ptr48[0..][0..1 :1]; +} +fn fn859() void { + _ = src_ptr48[0..][0..dest_len :1]; +} +fn fn860() void { + _ = src_ptr48[1..1 :1]; +} +fn fn861() void { + _ = src_ptr48[1..dest_end :1]; +} +var src_mem32: [3]u8 = .{ 0, 0, 0 }; +var src_ptr49: [*c]u8 = @ptrCast(&src_mem32); +fn fn862() void { + _ = src_ptr49[0..2 :1]; +} +fn fn863() void { + _ = src_ptr49[0..1 :1]; +} +fn fn864() void { + _ = src_ptr49[0..dest_end :1]; +} +fn fn865() void { + _ = src_ptr49[0..][0..2 :1]; +} +fn fn866() void { + _ = src_ptr49[0..][0..1 :1]; +} +fn fn867() void { + _ = src_ptr49[0..][0..dest_len :1]; +} +fn fn868() void { + _ = src_ptr49[1..2 :1]; +} +fn fn869() void { + _ = src_ptr49[1..1 :1]; +} +fn fn870() void { + _ = src_ptr49[1..dest_end :1]; +} +fn fn871() void { + _ = src_ptr49[1..][0..1 :1]; +} +fn fn872() void { + _ = src_ptr49[1..][0..dest_len :1]; +} +const src_mem33: [2]u8 = .{ 0, 0 }; +const src_ptr50: *const [2]u8 = src_mem33[0..2]; +fn fn873() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr50[0..dest_end]; +} +fn fn874() void { + dest_len = 3; + _ = src_ptr50[0..][0..dest_len]; +} +fn fn875() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr50[1..dest_end]; +} +fn fn876() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr50[1..][0..dest_len]; +} +fn fn877() void { + _ = src_ptr50[0..dest_end :1]; +} +fn fn878() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr50[0..dest_end :1]; +} +fn fn879() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr50[0..][0..dest_len :1]; +} +fn fn880() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr50[0..][0..dest_len :1]; +} +fn fn881() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr50[1..dest_end :1]; +} +fn fn882() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr50[1..dest_end :1]; +} +fn fn883() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr50[1..][0..dest_len :1]; +} +fn fn884() void { + dest_len = 1; + _ = src_ptr50[1..][0..dest_len :1]; +} +const src_mem34: [2]u8 = .{ 0, 0 }; +const src_ptr51: *const [1:0]u8 = src_mem34[0..1 :0]; +fn fn885() void { + dest_end = 3; + _ = src_ptr51[0..dest_end]; +} +fn fn886() void { + dest_len = 3; + _ = src_ptr51[0..][0..dest_len]; +} +fn fn887() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr51[1..dest_end]; +} +fn fn888() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr51[1..][0..dest_len]; +} +fn fn889() void { + _ = src_ptr51[0..dest_end :1]; +} +fn fn890() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr51[0..dest_end :1]; +} +fn fn891() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr51[0..][0..dest_len :1]; +} +fn fn892() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr51[0..][0..dest_len :1]; +} +fn fn893() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr51[1..dest_end :1]; +} +fn fn894() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr51[1..dest_end :1]; +} +fn fn895() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr51[1..][0..dest_len :1]; +} +fn fn896() void { + dest_len = 1; + _ = src_ptr51[1..][0..dest_len :1]; +} +const src_mem35: [3]u8 = .{ 0, 0, 0 }; +const src_ptr52: *const [3]u8 = src_mem35[0..3]; +fn fn897() void { + dest_len = 3; + _ = src_ptr52[1..][0..dest_len]; +} +fn fn898() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr52[3..dest_end]; +} +fn fn899() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr52[3..][0..dest_len]; +} +fn fn900() void { + dest_len = 1; + _ = src_ptr52[3..][0..dest_len]; +} +fn fn901() void { + dest_end = 3; + _ = src_ptr52[0..dest_end :1]; +} +fn fn902() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr52[0..dest_end :1]; +} +fn fn903() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr52[0..][0..dest_len :1]; +} +fn fn904() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr52[0..][0..dest_len :1]; +} +fn fn905() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr52[1..dest_end :1]; +} +fn fn906() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr52[1..dest_end :1]; +} +fn fn907() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr52[1..][0..dest_len :1]; +} +fn fn908() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr52[1..][0..dest_len :1]; +} +const src_mem36: [3]u8 = .{ 0, 0, 0 }; +const src_ptr53: *const [2:0]u8 = src_mem36[0..2 :0]; +fn fn909() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr53[1..][0..dest_len]; +} +fn fn910() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr53[3..dest_end]; +} +fn fn911() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr53[3..][0..dest_len]; +} +fn fn912() void { + dest_len = 1; + _ = src_ptr53[3..][0..dest_len]; +} +fn fn913() void { + dest_end = 3; + _ = src_ptr53[0..dest_end :1]; +} +fn fn914() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr53[0..dest_end :1]; +} +fn fn915() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr53[0..][0..dest_len :1]; +} +fn fn916() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr53[0..][0..dest_len :1]; +} +fn fn917() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr53[1..dest_end :1]; +} +fn fn918() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr53[1..dest_end :1]; +} +fn fn919() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr53[1..][0..dest_len :1]; +} +fn fn920() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr53[1..][0..dest_len :1]; +} +const src_mem37: [1]u8 = .{0}; +const src_ptr54: *const [1]u8 = src_mem37[0..1]; +fn fn921() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr54[0..dest_end]; +} +fn fn922() void { + dest_len = 3; + _ = src_ptr54[0..][0..dest_len]; +} +fn fn923() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr54[1..dest_end]; +} +fn fn924() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr54[1..][0..dest_len]; +} +fn fn925() void { + dest_len = 1; + _ = src_ptr54[1..][0..dest_len]; +} +fn fn926() void { + _ = src_ptr54[0..dest_end :1]; +} +fn fn927() void { + dest_end = 1; + _ = src_ptr54[0..dest_end :1]; +} +fn fn928() void { + dest_len = 3; + _ = src_ptr54[0..][0..dest_len :1]; +} +fn fn929() void { + dest_len = 1; + _ = src_ptr54[0..][0..dest_len :1]; +} +const src_mem38: [1]u8 = .{0}; +const src_ptr55: *const [0:0]u8 = src_mem38[0..0 :0]; +fn fn930() void { + dest_end = 3; + _ = src_ptr55[0..dest_end]; +} +fn fn931() void { + dest_len = 3; + _ = src_ptr55[0..][0..dest_len]; +} +fn fn932() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr55[1..dest_end]; +} +fn fn933() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr55[1..][0..dest_len]; +} +fn fn934() void { + dest_len = 1; + _ = src_ptr55[1..][0..dest_len]; +} +fn fn935() void { + _ = src_ptr55[0..dest_end :1]; +} +fn fn936() void { + dest_end = 1; + _ = src_ptr55[0..dest_end :1]; +} +fn fn937() void { + dest_len = 3; + _ = src_ptr55[0..][0..dest_len :1]; +} +fn fn938() void { + dest_len = 1; + _ = src_ptr55[0..][0..dest_len :1]; +} +const src_mem39: [2]u8 = .{ 0, 0 }; +var src_ptr56: *const [2]u8 = src_mem39[0..2]; +fn fn939() void { + dest_end = 3; + _ = src_ptr56[0..dest_end]; +} +fn fn940() void { + dest_len = 3; + _ = src_ptr56[0..][0..dest_len]; +} +fn fn941() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr56[1..dest_end]; +} +fn fn942() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr56[1..][0..dest_len]; +} +fn fn943() void { + expect_id = .mismatched_sentinel; + _ = src_ptr56[0..1 :1]; +} +fn fn944() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr56[0..dest_end :1]; +} +fn fn945() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr56[0..dest_end :1]; +} +fn fn946() void { + _ = src_ptr56[0..][0..1 :1]; +} +fn fn947() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr56[0..][0..dest_len :1]; +} +fn fn948() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr56[0..][0..dest_len :1]; +} +fn fn949() void { + _ = src_ptr56[1..1 :1]; +} +fn fn950() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr56[1..dest_end :1]; +} +fn fn951() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr56[1..dest_end :1]; +} +fn fn952() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr56[1..][0..dest_len :1]; +} +fn fn953() void { + dest_len = 1; + _ = src_ptr56[1..][0..dest_len :1]; +} +const src_mem40: [2]u8 = .{ 0, 0 }; +var src_ptr57: *const [1:0]u8 = src_mem40[0..1 :0]; +fn fn954() void { + dest_end = 3; + _ = src_ptr57[0..dest_end]; +} +fn fn955() void { + dest_len = 3; + _ = src_ptr57[0..][0..dest_len]; +} +fn fn956() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr57[1..dest_end]; +} +fn fn957() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr57[1..][0..dest_len]; +} +fn fn958() void { + expect_id = .mismatched_sentinel; + _ = src_ptr57[0.. :1]; +} +fn fn959() void { + _ = src_ptr57[0..1 :1]; +} +fn fn960() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr57[0..dest_end :1]; +} +fn fn961() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr57[0..dest_end :1]; +} +fn fn962() void { + _ = src_ptr57[0..][0..1 :1]; +} +fn fn963() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr57[0..][0..dest_len :1]; +} +fn fn964() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr57[0..][0..dest_len :1]; +} +fn fn965() void { + _ = src_ptr57[1.. :1]; +} +fn fn966() void { + _ = src_ptr57[1..1 :1]; +} +fn fn967() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr57[1..dest_end :1]; +} +fn fn968() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr57[1..dest_end :1]; +} +fn fn969() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr57[1..][0..dest_len :1]; +} +fn fn970() void { + dest_len = 1; + _ = src_ptr57[1..][0..dest_len :1]; +} +const src_mem41: [3]u8 = .{ 0, 0, 0 }; +var src_ptr58: *const [3]u8 = src_mem41[0..3]; +fn fn971() void { + dest_len = 3; + _ = src_ptr58[1..][0..dest_len]; +} +fn fn972() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr58[3..dest_end]; +} +fn fn973() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr58[3..][0..dest_len]; +} +fn fn974() void { + dest_len = 1; + _ = src_ptr58[3..][0..dest_len]; +} +fn fn975() void { + expect_id = .mismatched_sentinel; + _ = src_ptr58[0..2 :1]; +} +fn fn976() void { + _ = src_ptr58[0..1 :1]; +} +fn fn977() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr58[0..dest_end :1]; +} +fn fn978() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr58[0..dest_end :1]; +} +fn fn979() void { + _ = src_ptr58[0..][0..2 :1]; +} +fn fn980() void { + _ = src_ptr58[0..][0..1 :1]; +} +fn fn981() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr58[0..][0..dest_len :1]; +} +fn fn982() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr58[0..][0..dest_len :1]; +} +fn fn983() void { + _ = src_ptr58[1..2 :1]; +} +fn fn984() void { + _ = src_ptr58[1..1 :1]; +} +fn fn985() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr58[1..dest_end :1]; +} +fn fn986() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr58[1..dest_end :1]; +} +fn fn987() void { + _ = src_ptr58[1..][0..1 :1]; +} +fn fn988() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr58[1..][0..dest_len :1]; +} +fn fn989() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr58[1..][0..dest_len :1]; +} +const src_mem42: [3]u8 = .{ 0, 0, 0 }; +var src_ptr59: *const [2:0]u8 = src_mem42[0..2 :0]; +fn fn990() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr59[1..][0..dest_len]; +} +fn fn991() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr59[3..dest_end]; +} +fn fn992() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr59[3..][0..dest_len]; +} +fn fn993() void { + dest_len = 1; + _ = src_ptr59[3..][0..dest_len]; +} +fn fn994() void { + expect_id = .mismatched_sentinel; + _ = src_ptr59[0.. :1]; +} +fn fn995() void { + _ = src_ptr59[0..2 :1]; +} +fn fn996() void { + _ = src_ptr59[0..1 :1]; +} +fn fn997() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr59[0..dest_end :1]; +} +fn fn998() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr59[0..dest_end :1]; +} +fn fn999() void { + _ = src_ptr59[0..][0..2 :1]; +} +fn fn1000() void { + _ = src_ptr59[0..][0..1 :1]; +} +fn fn1001() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr59[0..][0..dest_len :1]; +} +fn fn1002() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr59[0..][0..dest_len :1]; +} +fn fn1003() void { + _ = src_ptr59[1.. :1]; +} +fn fn1004() void { + _ = src_ptr59[1..2 :1]; +} +fn fn1005() void { + _ = src_ptr59[1..1 :1]; +} +fn fn1006() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr59[1..dest_end :1]; +} +fn fn1007() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr59[1..dest_end :1]; +} +fn fn1008() void { + _ = src_ptr59[1..][0..1 :1]; +} +fn fn1009() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr59[1..][0..dest_len :1]; +} +fn fn1010() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr59[1..][0..dest_len :1]; +} +const src_mem43: [1]u8 = .{0}; +var src_ptr60: *const [1]u8 = src_mem43[0..1]; +fn fn1011() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr60[0..dest_end]; +} +fn fn1012() void { + dest_len = 3; + _ = src_ptr60[0..][0..dest_len]; +} +fn fn1013() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr60[1..dest_end]; +} +fn fn1014() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr60[1..][0..dest_len]; +} +fn fn1015() void { + dest_len = 1; + _ = src_ptr60[1..][0..dest_len]; +} +fn fn1016() void { + _ = src_ptr60[0..dest_end :1]; +} +fn fn1017() void { + dest_end = 1; + _ = src_ptr60[0..dest_end :1]; +} +fn fn1018() void { + dest_len = 3; + _ = src_ptr60[0..][0..dest_len :1]; +} +fn fn1019() void { + dest_len = 1; + _ = src_ptr60[0..][0..dest_len :1]; +} +const src_mem44: [1]u8 = .{0}; +var src_ptr61: *const [0:0]u8 = src_mem44[0..0 :0]; +fn fn1020() void { + dest_end = 3; + _ = src_ptr61[0..dest_end]; +} +fn fn1021() void { + dest_len = 3; + _ = src_ptr61[0..][0..dest_len]; +} +fn fn1022() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr61[1..dest_end]; +} +fn fn1023() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr61[1..][0..dest_len]; +} +fn fn1024() void { + dest_len = 1; + _ = src_ptr61[1..][0..dest_len]; +} +fn fn1025() void { + expect_id = .mismatched_sentinel; + _ = src_ptr61[0.. :1]; +} +fn fn1026() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr61[0..dest_end :1]; +} +fn fn1027() void { + dest_end = 1; + _ = src_ptr61[0..dest_end :1]; +} +fn fn1028() void { + dest_len = 3; + _ = src_ptr61[0..][0..dest_len :1]; +} +fn fn1029() void { + dest_len = 1; + _ = src_ptr61[0..][0..dest_len :1]; +} +const src_mem45: [2]u8 = .{ 0, 0 }; +const src_ptr62: []const u8 = src_mem45[0..2]; +fn fn1030() void { + dest_end = 3; + _ = src_ptr62[0..dest_end]; +} +fn fn1031() void { + dest_len = 3; + _ = src_ptr62[0..][0..dest_len]; +} +fn fn1032() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr62[1..dest_end]; +} +fn fn1033() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr62[1..][0..dest_len]; +} +fn fn1034() void { + _ = src_ptr62[0..dest_end :1]; +} +fn fn1035() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr62[0..dest_end :1]; +} +fn fn1036() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr62[0..][0..dest_len :1]; +} +fn fn1037() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr62[0..][0..dest_len :1]; +} +fn fn1038() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr62[1..dest_end :1]; +} +fn fn1039() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr62[1..dest_end :1]; +} +fn fn1040() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr62[1..][0..dest_len :1]; +} +fn fn1041() void { + dest_len = 1; + _ = src_ptr62[1..][0..dest_len :1]; +} +const src_mem46: [2]u8 = .{ 0, 0 }; +const src_ptr63: [:0]const u8 = src_mem46[0..1 :0]; +fn fn1042() void { + dest_end = 3; + _ = src_ptr63[0..dest_end]; +} +fn fn1043() void { + dest_len = 3; + _ = src_ptr63[0..][0..dest_len]; +} +fn fn1044() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr63[1..dest_end]; +} +fn fn1045() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr63[1..][0..dest_len]; +} +fn fn1046() void { + _ = src_ptr63[0..dest_end :1]; +} +fn fn1047() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr63[0..dest_end :1]; +} +fn fn1048() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr63[0..][0..dest_len :1]; +} +fn fn1049() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr63[0..][0..dest_len :1]; +} +fn fn1050() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr63[1..dest_end :1]; +} +fn fn1051() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr63[1..dest_end :1]; +} +fn fn1052() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr63[1..][0..dest_len :1]; +} +fn fn1053() void { + dest_len = 1; + _ = src_ptr63[1..][0..dest_len :1]; +} +const src_mem47: [3]u8 = .{ 0, 0, 0 }; +const src_ptr64: []const u8 = src_mem47[0..3]; +fn fn1054() void { + dest_len = 3; + _ = src_ptr64[1..][0..dest_len]; +} +fn fn1055() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr64[3..dest_end]; +} +fn fn1056() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr64[3..][0..dest_len]; +} +fn fn1057() void { + dest_len = 1; + _ = src_ptr64[3..][0..dest_len]; +} +fn fn1058() void { + dest_end = 3; + _ = src_ptr64[0..dest_end :1]; +} +fn fn1059() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr64[0..dest_end :1]; +} +fn fn1060() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr64[0..][0..dest_len :1]; +} +fn fn1061() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr64[0..][0..dest_len :1]; +} +fn fn1062() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr64[1..dest_end :1]; +} +fn fn1063() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr64[1..dest_end :1]; +} +fn fn1064() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr64[1..][0..dest_len :1]; +} +fn fn1065() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr64[1..][0..dest_len :1]; +} +const src_mem48: [3]u8 = .{ 0, 0, 0 }; +const src_ptr65: [:0]const u8 = src_mem48[0..2 :0]; +fn fn1066() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr65[1..][0..dest_len]; +} +fn fn1067() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr65[3..dest_end]; +} +fn fn1068() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr65[3..][0..dest_len]; +} +fn fn1069() void { + dest_len = 1; + _ = src_ptr65[3..][0..dest_len]; +} +fn fn1070() void { + dest_end = 3; + _ = src_ptr65[0..dest_end :1]; +} +fn fn1071() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr65[0..dest_end :1]; +} +fn fn1072() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr65[0..][0..dest_len :1]; +} +fn fn1073() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr65[0..][0..dest_len :1]; +} +fn fn1074() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr65[1..dest_end :1]; +} +fn fn1075() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr65[1..dest_end :1]; +} +fn fn1076() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr65[1..][0..dest_len :1]; +} +fn fn1077() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr65[1..][0..dest_len :1]; +} +const src_mem49: [1]u8 = .{0}; +const src_ptr66: []const u8 = src_mem49[0..1]; +fn fn1078() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr66[0..dest_end]; +} +fn fn1079() void { + dest_len = 3; + _ = src_ptr66[0..][0..dest_len]; +} +fn fn1080() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr66[1..dest_end]; +} +fn fn1081() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr66[1..][0..dest_len]; +} +fn fn1082() void { + dest_len = 1; + _ = src_ptr66[1..][0..dest_len]; +} +fn fn1083() void { + _ = src_ptr66[0..dest_end :1]; +} +fn fn1084() void { + dest_end = 1; + _ = src_ptr66[0..dest_end :1]; +} +fn fn1085() void { + dest_len = 3; + _ = src_ptr66[0..][0..dest_len :1]; +} +fn fn1086() void { + dest_len = 1; + _ = src_ptr66[0..][0..dest_len :1]; +} +const src_mem50: [1]u8 = .{0}; +const src_ptr67: [:0]const u8 = src_mem50[0..0 :0]; +fn fn1087() void { + dest_end = 3; + _ = src_ptr67[0..dest_end]; +} +fn fn1088() void { + dest_len = 3; + _ = src_ptr67[0..][0..dest_len]; +} +fn fn1089() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr67[1..dest_end]; +} +fn fn1090() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr67[1..][0..dest_len]; +} +fn fn1091() void { + dest_len = 1; + _ = src_ptr67[1..][0..dest_len]; +} +fn fn1092() void { + _ = src_ptr67[0..dest_end :1]; +} +fn fn1093() void { + dest_end = 1; + _ = src_ptr67[0..dest_end :1]; +} +fn fn1094() void { + dest_len = 3; + _ = src_ptr67[0..][0..dest_len :1]; +} +fn fn1095() void { + dest_len = 1; + _ = src_ptr67[0..][0..dest_len :1]; +} +const src_mem51: [2]u8 = .{ 0, 0 }; +var src_ptr68: []const u8 = src_mem51[0..2]; +fn fn1096() void { + _ = src_ptr68[0..3]; +} +fn fn1097() void { + dest_end = 3; + _ = src_ptr68[0..dest_end]; +} +fn fn1098() void { + _ = src_ptr68[0..][0..3]; +} +fn fn1099() void { + dest_len = 3; + _ = src_ptr68[0..][0..dest_len]; +} +fn fn1100() void { + _ = src_ptr68[1..3]; +} +fn fn1101() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr68[1..dest_end]; +} +fn fn1102() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[1..][0..2]; +} +fn fn1103() void { + _ = src_ptr68[1..][0..3]; +} +fn fn1104() void { + _ = src_ptr68[1..][0..dest_len]; +} +fn fn1105() void { + expect_id = .accessed_out_of_order; + _ = src_ptr68[3..]; +} +fn fn1106() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[3..3]; +} +fn fn1107() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr68[3..dest_end]; +} +fn fn1108() void { + dest_end = 1; + _ = src_ptr68[3..dest_end]; +} +fn fn1109() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[3..][0..2]; +} +fn fn1110() void { + _ = src_ptr68[3..][0..3]; +} +fn fn1111() void { + _ = src_ptr68[3..][0..1]; +} +fn fn1112() void { + _ = src_ptr68[3..][0..dest_len]; +} +fn fn1113() void { + dest_len = 1; + _ = src_ptr68[3..][0..dest_len]; +} +fn fn1114() void { + _ = src_ptr68[0..2 :1]; +} +fn fn1115() void { + _ = src_ptr68[0..3 :1]; +} +fn fn1116() void { + expect_id = .mismatched_sentinel; + _ = src_ptr68[0..1 :1]; +} +fn fn1117() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr68[0..dest_end :1]; +} +fn fn1118() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr68[0..dest_end :1]; +} +fn fn1119() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[0..][0..2 :1]; +} +fn fn1120() void { + _ = src_ptr68[0..][0..3 :1]; +} +fn fn1121() void { + expect_id = .mismatched_sentinel; + _ = src_ptr68[0..][0..1 :1]; +} +fn fn1122() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr68[0..][0..dest_len :1]; +} +fn fn1123() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr68[0..][0..dest_len :1]; +} +fn fn1124() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[1..2 :1]; +} +fn fn1125() void { + _ = src_ptr68[1..3 :1]; +} +fn fn1126() void { + expect_id = .mismatched_sentinel; + _ = src_ptr68[1..1 :1]; +} +fn fn1127() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr68[1..dest_end :1]; +} +fn fn1128() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr68[1..dest_end :1]; +} +fn fn1129() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[1..][0..2 :1]; +} +fn fn1130() void { + _ = src_ptr68[1..][0..3 :1]; +} +fn fn1131() void { + _ = src_ptr68[1..][0..1 :1]; +} +fn fn1132() void { + dest_len = 3; + _ = src_ptr68[1..][0..dest_len :1]; +} +fn fn1133() void { + dest_len = 1; + _ = src_ptr68[1..][0..dest_len :1]; +} +fn fn1134() void { + _ = src_ptr68[3..3 :1]; +} +fn fn1135() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr68[3..dest_end :1]; +} +fn fn1136() void { + dest_end = 1; + _ = src_ptr68[3..dest_end :1]; +} +fn fn1137() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr68[3..][0..2 :1]; +} +fn fn1138() void { + _ = src_ptr68[3..][0..3 :1]; +} +fn fn1139() void { + _ = src_ptr68[3..][0..1 :1]; +} +fn fn1140() void { + dest_len = 3; + _ = src_ptr68[3..][0..dest_len :1]; +} +fn fn1141() void { + dest_len = 1; + _ = src_ptr68[3..][0..dest_len :1]; +} +const src_mem52: [2]u8 = .{ 0, 0 }; +var src_ptr69: [:0]const u8 = src_mem52[0..1 :0]; +fn fn1142() void { + _ = src_ptr69[0..3]; +} +fn fn1143() void { + dest_end = 3; + _ = src_ptr69[0..dest_end]; +} +fn fn1144() void { + _ = src_ptr69[0..][0..3]; +} +fn fn1145() void { + dest_len = 3; + _ = src_ptr69[0..][0..dest_len]; +} +fn fn1146() void { + _ = src_ptr69[1..3]; +} +fn fn1147() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr69[1..dest_end]; +} +fn fn1148() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[1..][0..2]; +} +fn fn1149() void { + _ = src_ptr69[1..][0..3]; +} +fn fn1150() void { + _ = src_ptr69[1..][0..dest_len]; +} +fn fn1151() void { + expect_id = .accessed_out_of_order; + _ = src_ptr69[3..]; +} +fn fn1152() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[3..3]; +} +fn fn1153() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr69[3..dest_end]; +} +fn fn1154() void { + dest_end = 1; + _ = src_ptr69[3..dest_end]; +} +fn fn1155() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[3..][0..2]; +} +fn fn1156() void { + _ = src_ptr69[3..][0..3]; +} +fn fn1157() void { + _ = src_ptr69[3..][0..1]; +} +fn fn1158() void { + _ = src_ptr69[3..][0..dest_len]; +} +fn fn1159() void { + dest_len = 1; + _ = src_ptr69[3..][0..dest_len]; +} +fn fn1160() void { + expect_id = .mismatched_sentinel; + _ = src_ptr69[0.. :1]; +} +fn fn1161() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[0..2 :1]; +} +fn fn1162() void { + _ = src_ptr69[0..3 :1]; +} +fn fn1163() void { + expect_id = .mismatched_sentinel; + _ = src_ptr69[0..1 :1]; +} +fn fn1164() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr69[0..dest_end :1]; +} +fn fn1165() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr69[0..dest_end :1]; +} +fn fn1166() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[0..][0..2 :1]; +} +fn fn1167() void { + _ = src_ptr69[0..][0..3 :1]; +} +fn fn1168() void { + expect_id = .mismatched_sentinel; + _ = src_ptr69[0..][0..1 :1]; +} +fn fn1169() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr69[0..][0..dest_len :1]; +} +fn fn1170() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr69[0..][0..dest_len :1]; +} +fn fn1171() void { + _ = src_ptr69[1.. :1]; +} +fn fn1172() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[1..2 :1]; +} +fn fn1173() void { + _ = src_ptr69[1..3 :1]; +} +fn fn1174() void { + expect_id = .mismatched_sentinel; + _ = src_ptr69[1..1 :1]; +} +fn fn1175() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr69[1..dest_end :1]; +} +fn fn1176() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr69[1..dest_end :1]; +} +fn fn1177() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[1..][0..2 :1]; +} +fn fn1178() void { + _ = src_ptr69[1..][0..3 :1]; +} +fn fn1179() void { + _ = src_ptr69[1..][0..1 :1]; +} +fn fn1180() void { + dest_len = 3; + _ = src_ptr69[1..][0..dest_len :1]; +} +fn fn1181() void { + dest_len = 1; + _ = src_ptr69[1..][0..dest_len :1]; +} +fn fn1182() void { + expect_id = .accessed_out_of_order; + _ = src_ptr69[3.. :1]; +} +fn fn1183() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[3..3 :1]; +} +fn fn1184() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr69[3..dest_end :1]; +} +fn fn1185() void { + dest_end = 1; + _ = src_ptr69[3..dest_end :1]; +} +fn fn1186() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr69[3..][0..2 :1]; +} +fn fn1187() void { + _ = src_ptr69[3..][0..3 :1]; +} +fn fn1188() void { + _ = src_ptr69[3..][0..1 :1]; +} +fn fn1189() void { + dest_len = 3; + _ = src_ptr69[3..][0..dest_len :1]; +} +fn fn1190() void { + dest_len = 1; + _ = src_ptr69[3..][0..dest_len :1]; +} +const src_mem53: [3]u8 = .{ 0, 0, 0 }; +var src_ptr70: []const u8 = src_mem53[0..3]; +fn fn1191() void { + _ = src_ptr70[1..][0..3]; +} +fn fn1192() void { + dest_len = 3; + _ = src_ptr70[1..][0..dest_len]; +} +fn fn1193() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr70[3..dest_end]; +} +fn fn1194() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[3..][0..2]; +} +fn fn1195() void { + _ = src_ptr70[3..][0..3]; +} +fn fn1196() void { + _ = src_ptr70[3..][0..1]; +} +fn fn1197() void { + _ = src_ptr70[3..][0..dest_len]; +} +fn fn1198() void { + dest_len = 1; + _ = src_ptr70[3..][0..dest_len]; +} +fn fn1199() void { + expect_id = .mismatched_sentinel; + _ = src_ptr70[0..2 :1]; +} +fn fn1200() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[0..3 :1]; +} +fn fn1201() void { + expect_id = .mismatched_sentinel; + _ = src_ptr70[0..1 :1]; +} +fn fn1202() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr70[0..dest_end :1]; +} +fn fn1203() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr70[0..dest_end :1]; +} +fn fn1204() void { + _ = src_ptr70[0..][0..2 :1]; +} +fn fn1205() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[0..][0..3 :1]; +} +fn fn1206() void { + expect_id = .mismatched_sentinel; + _ = src_ptr70[0..][0..1 :1]; +} +fn fn1207() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr70[0..][0..dest_len :1]; +} +fn fn1208() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr70[0..][0..dest_len :1]; +} +fn fn1209() void { + _ = src_ptr70[1..2 :1]; +} +fn fn1210() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[1..3 :1]; +} +fn fn1211() void { + expect_id = .mismatched_sentinel; + _ = src_ptr70[1..1 :1]; +} +fn fn1212() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr70[1..dest_end :1]; +} +fn fn1213() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr70[1..dest_end :1]; +} +fn fn1214() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[1..][0..2 :1]; +} +fn fn1215() void { + _ = src_ptr70[1..][0..3 :1]; +} +fn fn1216() void { + expect_id = .mismatched_sentinel; + _ = src_ptr70[1..][0..1 :1]; +} +fn fn1217() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr70[1..][0..dest_len :1]; +} +fn fn1218() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr70[1..][0..dest_len :1]; +} +fn fn1219() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[3..3 :1]; +} +fn fn1220() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr70[3..dest_end :1]; +} +fn fn1221() void { + dest_end = 1; + _ = src_ptr70[3..dest_end :1]; +} +fn fn1222() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr70[3..][0..2 :1]; +} +fn fn1223() void { + _ = src_ptr70[3..][0..3 :1]; +} +fn fn1224() void { + _ = src_ptr70[3..][0..1 :1]; +} +fn fn1225() void { + dest_len = 3; + _ = src_ptr70[3..][0..dest_len :1]; +} +fn fn1226() void { + dest_len = 1; + _ = src_ptr70[3..][0..dest_len :1]; +} +const src_mem54: [3]u8 = .{ 0, 0, 0 }; +var src_ptr71: [:0]const u8 = src_mem54[0..2 :0]; +fn fn1227() void { + _ = src_ptr71[1..][0..3]; +} +fn fn1228() void { + dest_len = 3; + _ = src_ptr71[1..][0..dest_len]; +} +fn fn1229() void { + expect_id = .accessed_out_of_order; + _ = src_ptr71[3..]; +} +fn fn1230() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr71[3..dest_end]; +} +fn fn1231() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[3..][0..2]; +} +fn fn1232() void { + _ = src_ptr71[3..][0..3]; +} +fn fn1233() void { + _ = src_ptr71[3..][0..1]; +} +fn fn1234() void { + _ = src_ptr71[3..][0..dest_len]; +} +fn fn1235() void { + dest_len = 1; + _ = src_ptr71[3..][0..dest_len]; +} +fn fn1236() void { + expect_id = .mismatched_sentinel; + _ = src_ptr71[0.. :1]; +} +fn fn1237() void { + _ = src_ptr71[0..2 :1]; +} +fn fn1238() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[0..3 :1]; +} +fn fn1239() void { + expect_id = .mismatched_sentinel; + _ = src_ptr71[0..1 :1]; +} +fn fn1240() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr71[0..dest_end :1]; +} +fn fn1241() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr71[0..dest_end :1]; +} +fn fn1242() void { + _ = src_ptr71[0..][0..2 :1]; +} +fn fn1243() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[0..][0..3 :1]; +} +fn fn1244() void { + expect_id = .mismatched_sentinel; + _ = src_ptr71[0..][0..1 :1]; +} +fn fn1245() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr71[0..][0..dest_len :1]; +} +fn fn1246() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr71[0..][0..dest_len :1]; +} +fn fn1247() void { + _ = src_ptr71[1.. :1]; +} +fn fn1248() void { + _ = src_ptr71[1..2 :1]; +} +fn fn1249() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[1..3 :1]; +} +fn fn1250() void { + expect_id = .mismatched_sentinel; + _ = src_ptr71[1..1 :1]; +} +fn fn1251() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr71[1..dest_end :1]; +} +fn fn1252() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr71[1..dest_end :1]; +} +fn fn1253() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[1..][0..2 :1]; +} +fn fn1254() void { + _ = src_ptr71[1..][0..3 :1]; +} +fn fn1255() void { + expect_id = .mismatched_sentinel; + _ = src_ptr71[1..][0..1 :1]; +} +fn fn1256() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr71[1..][0..dest_len :1]; +} +fn fn1257() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr71[1..][0..dest_len :1]; +} +fn fn1258() void { + expect_id = .accessed_out_of_order; + _ = src_ptr71[3.. :1]; +} +fn fn1259() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[3..3 :1]; +} +fn fn1260() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr71[3..dest_end :1]; +} +fn fn1261() void { + dest_end = 1; + _ = src_ptr71[3..dest_end :1]; +} +fn fn1262() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr71[3..][0..2 :1]; +} +fn fn1263() void { + _ = src_ptr71[3..][0..3 :1]; +} +fn fn1264() void { + _ = src_ptr71[3..][0..1 :1]; +} +fn fn1265() void { + dest_len = 3; + _ = src_ptr71[3..][0..dest_len :1]; +} +fn fn1266() void { + dest_len = 1; + _ = src_ptr71[3..][0..dest_len :1]; +} +const src_mem55: [1]u8 = .{0}; +var src_ptr72: []const u8 = src_mem55[0..1]; +fn fn1267() void { + _ = src_ptr72[0..2]; +} +fn fn1268() void { + _ = src_ptr72[0..3]; +} +fn fn1269() void { + dest_end = 3; + _ = src_ptr72[0..dest_end]; +} +fn fn1270() void { + _ = src_ptr72[0..][0..2]; +} +fn fn1271() void { + _ = src_ptr72[0..][0..3]; +} +fn fn1272() void { + dest_len = 3; + _ = src_ptr72[0..][0..dest_len]; +} +fn fn1273() void { + _ = src_ptr72[1..2]; +} +fn fn1274() void { + _ = src_ptr72[1..3]; +} +fn fn1275() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr72[1..dest_end]; +} +fn fn1276() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr72[1..][0..2]; +} +fn fn1277() void { + _ = src_ptr72[1..][0..3]; +} +fn fn1278() void { + _ = src_ptr72[1..][0..1]; +} +fn fn1279() void { + _ = src_ptr72[1..][0..dest_len]; +} +fn fn1280() void { + dest_len = 1; + _ = src_ptr72[1..][0..dest_len]; +} +fn fn1281() void { + expect_id = .accessed_out_of_order; + _ = src_ptr72[3..]; +} +fn fn1282() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr72[3..3]; +} +fn fn1283() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr72[3..dest_end]; +} +fn fn1284() void { + dest_end = 1; + _ = src_ptr72[3..dest_end]; +} +fn fn1285() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr72[3..][0..2]; +} +fn fn1286() void { + _ = src_ptr72[3..][0..3]; +} +fn fn1287() void { + _ = src_ptr72[3..][0..1]; +} +fn fn1288() void { + dest_len = 3; + _ = src_ptr72[3..][0..dest_len]; +} +fn fn1289() void { + dest_len = 1; + _ = src_ptr72[3..][0..dest_len]; +} +fn fn1290() void { + _ = src_ptr72[0..2 :1]; +} +fn fn1291() void { + _ = src_ptr72[0..3 :1]; +} +fn fn1292() void { + _ = src_ptr72[0..1 :1]; +} +fn fn1293() void { + dest_end = 3; + _ = src_ptr72[0..dest_end :1]; +} +fn fn1294() void { + dest_end = 1; + _ = src_ptr72[0..dest_end :1]; +} +fn fn1295() void { + _ = src_ptr72[0..][0..2 :1]; +} +fn fn1296() void { + _ = src_ptr72[0..][0..3 :1]; +} +fn fn1297() void { + _ = src_ptr72[0..][0..1 :1]; +} +fn fn1298() void { + dest_len = 3; + _ = src_ptr72[0..][0..dest_len :1]; +} +fn fn1299() void { + dest_len = 1; + _ = src_ptr72[0..][0..dest_len :1]; +} +fn fn1300() void { + _ = src_ptr72[1..2 :1]; +} +fn fn1301() void { + _ = src_ptr72[1..3 :1]; +} +fn fn1302() void { + _ = src_ptr72[1..1 :1]; +} +fn fn1303() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr72[1..dest_end :1]; +} +fn fn1304() void { + dest_end = 1; + _ = src_ptr72[1..dest_end :1]; +} +fn fn1305() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr72[1..][0..2 :1]; +} +fn fn1306() void { + _ = src_ptr72[1..][0..3 :1]; +} +fn fn1307() void { + _ = src_ptr72[1..][0..1 :1]; +} +fn fn1308() void { + dest_len = 3; + _ = src_ptr72[1..][0..dest_len :1]; +} +fn fn1309() void { + dest_len = 1; + _ = src_ptr72[1..][0..dest_len :1]; +} +fn fn1310() void { + _ = src_ptr72[3..3 :1]; +} +fn fn1311() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr72[3..dest_end :1]; +} +fn fn1312() void { + dest_end = 1; + _ = src_ptr72[3..dest_end :1]; +} +fn fn1313() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr72[3..][0..2 :1]; +} +fn fn1314() void { + _ = src_ptr72[3..][0..3 :1]; +} +fn fn1315() void { + _ = src_ptr72[3..][0..1 :1]; +} +fn fn1316() void { + dest_len = 3; + _ = src_ptr72[3..][0..dest_len :1]; +} +fn fn1317() void { + dest_len = 1; + _ = src_ptr72[3..][0..dest_len :1]; +} +const src_mem56: [1]u8 = .{0}; +var src_ptr73: [:0]const u8 = src_mem56[0..0 :0]; +fn fn1318() void { + _ = src_ptr73[0..2]; +} +fn fn1319() void { + _ = src_ptr73[0..3]; +} +fn fn1320() void { + dest_end = 3; + _ = src_ptr73[0..dest_end]; +} +fn fn1321() void { + _ = src_ptr73[0..][0..2]; +} +fn fn1322() void { + _ = src_ptr73[0..][0..3]; +} +fn fn1323() void { + dest_len = 3; + _ = src_ptr73[0..][0..dest_len]; +} +fn fn1324() void { + expect_id = .accessed_out_of_order; + _ = src_ptr73[1..]; +} +fn fn1325() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[1..2]; +} +fn fn1326() void { + _ = src_ptr73[1..3]; +} +fn fn1327() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr73[1..dest_end]; +} +fn fn1328() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[1..][0..2]; +} +fn fn1329() void { + _ = src_ptr73[1..][0..3]; +} +fn fn1330() void { + _ = src_ptr73[1..][0..1]; +} +fn fn1331() void { + _ = src_ptr73[1..][0..dest_len]; +} +fn fn1332() void { + dest_len = 1; + _ = src_ptr73[1..][0..dest_len]; +} +fn fn1333() void { + expect_id = .accessed_out_of_order; + _ = src_ptr73[3..]; +} +fn fn1334() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[3..3]; +} +fn fn1335() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr73[3..dest_end]; +} +fn fn1336() void { + dest_end = 1; + _ = src_ptr73[3..dest_end]; +} +fn fn1337() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[3..][0..2]; +} +fn fn1338() void { + _ = src_ptr73[3..][0..3]; +} +fn fn1339() void { + _ = src_ptr73[3..][0..1]; +} +fn fn1340() void { + dest_len = 3; + _ = src_ptr73[3..][0..dest_len]; +} +fn fn1341() void { + dest_len = 1; + _ = src_ptr73[3..][0..dest_len]; +} +fn fn1342() void { + expect_id = .mismatched_sentinel; + _ = src_ptr73[0.. :1]; +} +fn fn1343() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[0..2 :1]; +} +fn fn1344() void { + _ = src_ptr73[0..3 :1]; +} +fn fn1345() void { + _ = src_ptr73[0..1 :1]; +} +fn fn1346() void { + dest_end = 3; + _ = src_ptr73[0..dest_end :1]; +} +fn fn1347() void { + dest_end = 1; + _ = src_ptr73[0..dest_end :1]; +} +fn fn1348() void { + _ = src_ptr73[0..][0..2 :1]; +} +fn fn1349() void { + _ = src_ptr73[0..][0..3 :1]; +} +fn fn1350() void { + _ = src_ptr73[0..][0..1 :1]; +} +fn fn1351() void { + dest_len = 3; + _ = src_ptr73[0..][0..dest_len :1]; +} +fn fn1352() void { + dest_len = 1; + _ = src_ptr73[0..][0..dest_len :1]; +} +fn fn1353() void { + expect_id = .accessed_out_of_order; + _ = src_ptr73[1.. :1]; +} +fn fn1354() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[1..2 :1]; +} +fn fn1355() void { + _ = src_ptr73[1..3 :1]; +} +fn fn1356() void { + _ = src_ptr73[1..1 :1]; +} +fn fn1357() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr73[1..dest_end :1]; +} +fn fn1358() void { + dest_end = 1; + _ = src_ptr73[1..dest_end :1]; +} +fn fn1359() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[1..][0..2 :1]; +} +fn fn1360() void { + _ = src_ptr73[1..][0..3 :1]; +} +fn fn1361() void { + _ = src_ptr73[1..][0..1 :1]; +} +fn fn1362() void { + dest_len = 3; + _ = src_ptr73[1..][0..dest_len :1]; +} +fn fn1363() void { + dest_len = 1; + _ = src_ptr73[1..][0..dest_len :1]; +} +fn fn1364() void { + expect_id = .accessed_out_of_order; + _ = src_ptr73[3.. :1]; +} +fn fn1365() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[3..3 :1]; +} +fn fn1366() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr73[3..dest_end :1]; +} +fn fn1367() void { + dest_end = 1; + _ = src_ptr73[3..dest_end :1]; +} +fn fn1368() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr73[3..][0..2 :1]; +} +fn fn1369() void { + _ = src_ptr73[3..][0..3 :1]; +} +fn fn1370() void { + _ = src_ptr73[3..][0..1 :1]; +} +fn fn1371() void { + dest_len = 3; + _ = src_ptr73[3..][0..dest_len :1]; +} +fn fn1372() void { + dest_len = 1; + _ = src_ptr73[3..][0..dest_len :1]; +} +const src_mem57: [2]u8 = .{ 0, 0 }; +const src_ptr74: [*]const u8 = @ptrCast(&src_mem57); +fn fn1373() void { + expect_id = .mismatched_sentinel; + _ = src_ptr74[0..dest_end :1]; +} +fn fn1374() void { + _ = src_ptr74[0..][0..dest_len :1]; +} +fn fn1375() void { + _ = src_ptr74[1..dest_end :1]; +} +const src_mem58: [2]u8 = .{ 0, 0 }; +const src_ptr75: [*:0]const u8 = @ptrCast(&src_mem58); +fn fn1376() void { + _ = src_ptr75[0..dest_end :1]; +} +fn fn1377() void { + _ = src_ptr75[0..][0..dest_len :1]; +} +fn fn1378() void { + _ = src_ptr75[1..dest_end :1]; +} +const src_mem59: [3]u8 = .{ 0, 0, 0 }; +const src_ptr76: [*]const u8 = @ptrCast(&src_mem59); +fn fn1379() void { + _ = src_ptr76[0..dest_end :1]; +} +fn fn1380() void { + _ = src_ptr76[0..][0..dest_len :1]; +} +fn fn1381() void { + _ = src_ptr76[1..dest_end :1]; +} +fn fn1382() void { + _ = src_ptr76[1..][0..dest_len :1]; +} +const src_mem60: [3]u8 = .{ 0, 0, 0 }; +const src_ptr77: [*:0]const u8 = @ptrCast(&src_mem60); +fn fn1383() void { + _ = src_ptr77[0..dest_end :1]; +} +fn fn1384() void { + _ = src_ptr77[0..][0..dest_len :1]; +} +fn fn1385() void { + _ = src_ptr77[1..dest_end :1]; +} +fn fn1386() void { + _ = src_ptr77[1..][0..dest_len :1]; +} +const src_mem61: [2]u8 = .{ 0, 0 }; +var src_ptr78: [*]const u8 = @ptrCast(&src_mem61); +fn fn1387() void { + _ = src_ptr78[0..1 :1]; +} +fn fn1388() void { + _ = src_ptr78[0..dest_end :1]; +} +fn fn1389() void { + _ = src_ptr78[0..][0..1 :1]; +} +fn fn1390() void { + _ = src_ptr78[0..][0..dest_len :1]; +} +fn fn1391() void { + _ = src_ptr78[1..1 :1]; +} +fn fn1392() void { + _ = src_ptr78[1..dest_end :1]; +} +const src_mem62: [2]u8 = .{ 0, 0 }; +var src_ptr79: [*:0]const u8 = @ptrCast(&src_mem62); +fn fn1393() void { + _ = src_ptr79[0..1 :1]; +} +fn fn1394() void { + _ = src_ptr79[0..dest_end :1]; +} +fn fn1395() void { + _ = src_ptr79[0..][0..1 :1]; +} +fn fn1396() void { + _ = src_ptr79[0..][0..dest_len :1]; +} +fn fn1397() void { + _ = src_ptr79[1..1 :1]; +} +fn fn1398() void { + _ = src_ptr79[1..dest_end :1]; +} +const src_mem63: [3]u8 = .{ 0, 0, 0 }; +var src_ptr80: [*]const u8 = @ptrCast(&src_mem63); +fn fn1399() void { + _ = src_ptr80[0..2 :1]; +} +fn fn1400() void { + _ = src_ptr80[0..1 :1]; +} +fn fn1401() void { + _ = src_ptr80[0..dest_end :1]; +} +fn fn1402() void { + _ = src_ptr80[0..][0..2 :1]; +} +fn fn1403() void { + _ = src_ptr80[0..][0..1 :1]; +} +fn fn1404() void { + _ = src_ptr80[0..][0..dest_len :1]; +} +fn fn1405() void { + _ = src_ptr80[1..2 :1]; +} +fn fn1406() void { + _ = src_ptr80[1..1 :1]; +} +fn fn1407() void { + _ = src_ptr80[1..dest_end :1]; +} +fn fn1408() void { + _ = src_ptr80[1..][0..1 :1]; +} +fn fn1409() void { + _ = src_ptr80[1..][0..dest_len :1]; +} +const src_mem64: [3]u8 = .{ 0, 0, 0 }; +var src_ptr81: [*:0]const u8 = @ptrCast(&src_mem64); +fn fn1410() void { + _ = src_ptr81[0..2 :1]; +} +fn fn1411() void { + _ = src_ptr81[0..1 :1]; +} +fn fn1412() void { + _ = src_ptr81[0..dest_end :1]; +} +fn fn1413() void { + _ = src_ptr81[0..][0..2 :1]; +} +fn fn1414() void { + _ = src_ptr81[0..][0..1 :1]; +} +fn fn1415() void { + _ = src_ptr81[0..][0..dest_len :1]; +} +fn fn1416() void { + _ = src_ptr81[1..2 :1]; +} +fn fn1417() void { + _ = src_ptr81[1..1 :1]; +} +fn fn1418() void { + _ = src_ptr81[1..dest_end :1]; +} +fn fn1419() void { + _ = src_ptr81[1..][0..1 :1]; +} +fn fn1420() void { + _ = src_ptr81[1..][0..dest_len :1]; +} +var src_ptr82: [*c]const u8 = null; +fn fn1421() void { + expect_id = .accessed_null_value; + _ = src_ptr82[0..]; +} +fn fn1422() void { + _ = src_ptr82[0..2]; +} +fn fn1423() void { + _ = src_ptr82[0..3]; +} +fn fn1424() void { + _ = src_ptr82[0..1]; +} +fn fn1425() void { + dest_end = 3; + _ = src_ptr82[0..dest_end]; +} +fn fn1426() void { + dest_end = 1; + _ = src_ptr82[0..dest_end]; +} +fn fn1427() void { + _ = src_ptr82[0..][0..2]; +} +fn fn1428() void { + _ = src_ptr82[0..][0..3]; +} +fn fn1429() void { + _ = src_ptr82[0..][0..1]; +} +fn fn1430() void { + dest_len = 3; + _ = src_ptr82[0..][0..dest_len]; +} +fn fn1431() void { + dest_len = 1; + _ = src_ptr82[0..][0..dest_len]; +} +fn fn1432() void { + _ = src_ptr82[1..]; +} +fn fn1433() void { + _ = src_ptr82[1..2]; +} +fn fn1434() void { + _ = src_ptr82[1..3]; +} +fn fn1435() void { + _ = src_ptr82[1..1]; +} +fn fn1436() void { + dest_end = 3; + _ = src_ptr82[1..dest_end]; +} +fn fn1437() void { + dest_end = 1; + _ = src_ptr82[1..dest_end]; +} +fn fn1438() void { + _ = src_ptr82[1..][0..2]; +} +fn fn1439() void { + _ = src_ptr82[1..][0..3]; +} +fn fn1440() void { + _ = src_ptr82[1..][0..1]; +} +fn fn1441() void { + dest_len = 3; + _ = src_ptr82[1..][0..dest_len]; +} +fn fn1442() void { + dest_len = 1; + _ = src_ptr82[1..][0..dest_len]; +} +fn fn1443() void { + _ = src_ptr82[3..]; +} +fn fn1444() void { + _ = src_ptr82[3..3]; +} +fn fn1445() void { + dest_end = 3; + _ = src_ptr82[3..dest_end]; +} +fn fn1446() void { + _ = src_ptr82[3..][0..2]; +} +fn fn1447() void { + _ = src_ptr82[3..][0..3]; +} +fn fn1448() void { + _ = src_ptr82[3..][0..1]; +} +fn fn1449() void { + dest_len = 3; + _ = src_ptr82[3..][0..dest_len]; +} +fn fn1450() void { + dest_len = 1; + _ = src_ptr82[3..][0..dest_len]; +} +fn fn1451() void { + _ = src_ptr82[0.. :1]; +} +fn fn1452() void { + _ = src_ptr82[0..2 :1]; +} +fn fn1453() void { + _ = src_ptr82[0..3 :1]; +} +fn fn1454() void { + _ = src_ptr82[0..1 :1]; +} +fn fn1455() void { + _ = src_ptr82[0..dest_end :1]; +} +fn fn1456() void { + dest_end = 1; + _ = src_ptr82[0..dest_end :1]; +} +fn fn1457() void { + _ = src_ptr82[0..][0..2 :1]; +} +fn fn1458() void { + _ = src_ptr82[0..][0..3 :1]; +} +fn fn1459() void { + _ = src_ptr82[0..][0..1 :1]; +} +fn fn1460() void { + dest_len = 3; + _ = src_ptr82[0..][0..dest_len :1]; +} +fn fn1461() void { + dest_len = 1; + _ = src_ptr82[0..][0..dest_len :1]; +} +fn fn1462() void { + _ = src_ptr82[1.. :1]; +} +fn fn1463() void { + _ = src_ptr82[1..2 :1]; +} +fn fn1464() void { + _ = src_ptr82[1..3 :1]; +} +fn fn1465() void { + _ = src_ptr82[1..1 :1]; +} +fn fn1466() void { + dest_end = 3; + _ = src_ptr82[1..dest_end :1]; +} +fn fn1467() void { + dest_end = 1; + _ = src_ptr82[1..dest_end :1]; +} +fn fn1468() void { + _ = src_ptr82[1..][0..2 :1]; +} +fn fn1469() void { + _ = src_ptr82[1..][0..3 :1]; +} +fn fn1470() void { + _ = src_ptr82[1..][0..1 :1]; +} +fn fn1471() void { + dest_len = 3; + _ = src_ptr82[1..][0..dest_len :1]; +} +fn fn1472() void { + dest_len = 1; + _ = src_ptr82[1..][0..dest_len :1]; +} +fn fn1473() void { + _ = src_ptr82[3.. :1]; +} +fn fn1474() void { + _ = src_ptr82[3..3 :1]; +} +fn fn1475() void { + dest_end = 3; + _ = src_ptr82[3..dest_end :1]; +} +fn fn1476() void { + _ = src_ptr82[3..][0..2 :1]; +} +fn fn1477() void { + _ = src_ptr82[3..][0..3 :1]; +} +fn fn1478() void { + _ = src_ptr82[3..][0..1 :1]; +} +fn fn1479() void { + dest_len = 3; + _ = src_ptr82[3..][0..dest_len :1]; +} +fn fn1480() void { + dest_len = 1; + _ = src_ptr82[3..][0..dest_len :1]; +} +const src_mem65: [2]u8 = .{ 0, 0 }; +const src_ptr83: [*c]const u8 = @ptrCast(&src_mem65); +fn fn1481() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr83[0..dest_end :1]; +} +fn fn1482() void { + _ = src_ptr83[0..][0..dest_len :1]; +} +fn fn1483() void { + _ = src_ptr83[1..dest_end :1]; +} +const src_mem66: [3]u8 = .{ 0, 0, 0 }; +const src_ptr84: [*c]const u8 = @ptrCast(&src_mem66); +fn fn1484() void { + _ = src_ptr84[0..dest_end :1]; +} +fn fn1485() void { + _ = src_ptr84[0..][0..dest_len :1]; +} +fn fn1486() void { + _ = src_ptr84[1..dest_end :1]; +} +fn fn1487() void { + _ = src_ptr84[1..][0..dest_len :1]; +} +const src_mem67: [2]u8 = .{ 0, 0 }; +var src_ptr85: [*c]const u8 = @ptrCast(&src_mem67); +fn fn1488() void { + _ = src_ptr85[0..1 :1]; +} +fn fn1489() void { + _ = src_ptr85[0..dest_end :1]; +} +fn fn1490() void { + _ = src_ptr85[0..][0..1 :1]; +} +fn fn1491() void { + _ = src_ptr85[0..][0..dest_len :1]; +} +fn fn1492() void { + _ = src_ptr85[1..1 :1]; +} +fn fn1493() void { + _ = src_ptr85[1..dest_end :1]; +} +const src_mem68: [3]u8 = .{ 0, 0, 0 }; +var src_ptr86: [*c]const u8 = @ptrCast(&src_mem68); +fn fn1494() void { + _ = src_ptr86[0..2 :1]; +} +fn fn1495() void { + _ = src_ptr86[0..1 :1]; +} +fn fn1496() void { + _ = src_ptr86[0..dest_end :1]; +} +fn fn1497() void { + _ = src_ptr86[0..][0..2 :1]; +} +fn fn1498() void { + _ = src_ptr86[0..][0..1 :1]; +} +fn fn1499() void { + _ = src_ptr86[0..][0..dest_len :1]; +} +fn fn1500() void { + _ = src_ptr86[1..2 :1]; +} +fn fn1501() void { + _ = src_ptr86[1..1 :1]; +} +fn fn1502() void { + _ = src_ptr86[1..dest_end :1]; +} +fn fn1503() void { + _ = src_ptr86[1..][0..1 :1]; +} +fn fn1504() void { + _ = src_ptr86[1..][0..dest_len :1]; +} +const src_mem69: [2]u8 = .{ 1, 1 }; +const src_ptr87: *const [2]u8 = src_mem69[0..2]; +fn fn1505() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr87[0..dest_end]; +} +fn fn1506() void { + dest_len = 3; + _ = src_ptr87[0..][0..dest_len]; +} +fn fn1507() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr87[1..dest_end]; +} +fn fn1508() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr87[1..][0..dest_len]; +} +fn fn1509() void { + _ = src_ptr87[0..dest_end :1]; +} +fn fn1510() void { + _ = src_ptr87[0..][0..dest_len :1]; +} +fn fn1511() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr87[1..dest_end :1]; +} +fn fn1512() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr87[1..][0..dest_len :1]; +} +fn fn1513() void { + dest_len = 1; + _ = src_ptr87[1..][0..dest_len :1]; +} +const src_mem70: [2]u8 = .{ 1, 0 }; +const src_ptr88: *const [1:0]u8 = src_mem70[0..1 :0]; +fn fn1514() void { + _ = src_ptr88[0..dest_end]; +} +fn fn1515() void { + dest_len = 3; + _ = src_ptr88[0..][0..dest_len]; +} +fn fn1516() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr88[1..dest_end]; +} +fn fn1517() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr88[1..][0..dest_len]; +} +fn fn1518() void { + _ = src_ptr88[0..dest_end :1]; +} +fn fn1519() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr88[0..dest_end :1]; +} +fn fn1520() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr88[0..][0..dest_len :1]; +} +fn fn1521() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr88[0..][0..dest_len :1]; +} +fn fn1522() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr88[1..dest_end :1]; +} +fn fn1523() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr88[1..dest_end :1]; +} +fn fn1524() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr88[1..][0..dest_len :1]; +} +fn fn1525() void { + dest_len = 1; + _ = src_ptr88[1..][0..dest_len :1]; +} +const src_mem71: [3]u8 = .{ 1, 1, 1 }; +const src_ptr89: *const [3]u8 = src_mem71[0..3]; +fn fn1526() void { + dest_len = 3; + _ = src_ptr89[1..][0..dest_len]; +} +fn fn1527() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr89[3..dest_end]; +} +fn fn1528() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr89[3..][0..dest_len]; +} +fn fn1529() void { + dest_len = 1; + _ = src_ptr89[3..][0..dest_len]; +} +fn fn1530() void { + dest_end = 3; + _ = src_ptr89[0..dest_end :1]; +} +fn fn1531() void { + dest_len = 3; + _ = src_ptr89[0..][0..dest_len :1]; +} +fn fn1532() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr89[1..dest_end :1]; +} +fn fn1533() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr89[1..][0..dest_len :1]; +} +const src_mem72: [3]u8 = .{ 1, 1, 0 }; +const src_ptr90: *const [2:0]u8 = src_mem72[0..2 :0]; +fn fn1534() void { + _ = src_ptr90[1..][0..dest_len]; +} +fn fn1535() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr90[3..dest_end]; +} +fn fn1536() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr90[3..][0..dest_len]; +} +fn fn1537() void { + dest_len = 1; + _ = src_ptr90[3..][0..dest_len]; +} +fn fn1538() void { + dest_end = 3; + _ = src_ptr90[0..dest_end :1]; +} +fn fn1539() void { + dest_len = 3; + _ = src_ptr90[0..][0..dest_len :1]; +} +fn fn1540() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr90[1..dest_end :1]; +} +fn fn1541() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr90[1..][0..dest_len :1]; +} +fn fn1542() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr90[1..][0..dest_len :1]; +} +const src_mem73: [1]u8 = .{1}; +const src_ptr91: *const [1]u8 = src_mem73[0..1]; +fn fn1543() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr91[0..dest_end]; +} +fn fn1544() void { + dest_len = 3; + _ = src_ptr91[0..][0..dest_len]; +} +fn fn1545() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr91[1..dest_end]; +} +fn fn1546() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr91[1..][0..dest_len]; +} +fn fn1547() void { + dest_len = 1; + _ = src_ptr91[1..][0..dest_len]; +} +fn fn1548() void { + _ = src_ptr91[0..dest_end :1]; +} +fn fn1549() void { + dest_end = 1; + _ = src_ptr91[0..dest_end :1]; +} +fn fn1550() void { + dest_len = 3; + _ = src_ptr91[0..][0..dest_len :1]; +} +fn fn1551() void { + dest_len = 1; + _ = src_ptr91[0..][0..dest_len :1]; +} +const src_mem74: [1]u8 = .{0}; +const src_ptr92: *const [0:0]u8 = src_mem74[0..0 :0]; +fn fn1552() void { + dest_end = 3; + _ = src_ptr92[0..dest_end]; +} +fn fn1553() void { + dest_len = 3; + _ = src_ptr92[0..][0..dest_len]; +} +fn fn1554() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr92[1..dest_end]; +} +fn fn1555() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr92[1..][0..dest_len]; +} +fn fn1556() void { + dest_len = 1; + _ = src_ptr92[1..][0..dest_len]; +} +fn fn1557() void { + _ = src_ptr92[0..dest_end :1]; +} +fn fn1558() void { + dest_end = 1; + _ = src_ptr92[0..dest_end :1]; +} +fn fn1559() void { + dest_len = 3; + _ = src_ptr92[0..][0..dest_len :1]; +} +fn fn1560() void { + dest_len = 1; + _ = src_ptr92[0..][0..dest_len :1]; +} +const src_mem75: [2]u8 = .{ 1, 1 }; +var src_ptr93: *const [2]u8 = src_mem75[0..2]; +fn fn1561() void { + dest_end = 3; + _ = src_ptr93[0..dest_end]; +} +fn fn1562() void { + dest_len = 3; + _ = src_ptr93[0..][0..dest_len]; +} +fn fn1563() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr93[1..dest_end]; +} +fn fn1564() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr93[1..][0..dest_len]; +} +fn fn1565() void { + _ = src_ptr93[0..dest_end :1]; +} +fn fn1566() void { + _ = src_ptr93[0..][0..dest_len :1]; +} +fn fn1567() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr93[1..dest_end :1]; +} +fn fn1568() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr93[1..][0..dest_len :1]; +} +fn fn1569() void { + dest_len = 1; + _ = src_ptr93[1..][0..dest_len :1]; +} +const src_mem76: [2]u8 = .{ 1, 0 }; +var src_ptr94: *const [1:0]u8 = src_mem76[0..1 :0]; +fn fn1570() void { + _ = src_ptr94[0..dest_end]; +} +fn fn1571() void { + dest_len = 3; + _ = src_ptr94[0..][0..dest_len]; +} +fn fn1572() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr94[1..dest_end]; +} +fn fn1573() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr94[1..][0..dest_len]; +} +fn fn1574() void { + expect_id = .mismatched_sentinel; + _ = src_ptr94[0.. :1]; +} +fn fn1575() void { + _ = src_ptr94[0..1 :1]; +} +fn fn1576() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr94[0..dest_end :1]; +} +fn fn1577() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr94[0..dest_end :1]; +} +fn fn1578() void { + _ = src_ptr94[0..][0..1 :1]; +} +fn fn1579() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr94[0..][0..dest_len :1]; +} +fn fn1580() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr94[0..][0..dest_len :1]; +} +fn fn1581() void { + _ = src_ptr94[1.. :1]; +} +fn fn1582() void { + _ = src_ptr94[1..1 :1]; +} +fn fn1583() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr94[1..dest_end :1]; +} +fn fn1584() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr94[1..dest_end :1]; +} +fn fn1585() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr94[1..][0..dest_len :1]; +} +fn fn1586() void { + dest_len = 1; + _ = src_ptr94[1..][0..dest_len :1]; +} +const src_mem77: [3]u8 = .{ 1, 1, 1 }; +var src_ptr95: *const [3]u8 = src_mem77[0..3]; +fn fn1587() void { + dest_len = 3; + _ = src_ptr95[1..][0..dest_len]; +} +fn fn1588() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr95[3..dest_end]; +} +fn fn1589() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr95[3..][0..dest_len]; +} +fn fn1590() void { + dest_len = 1; + _ = src_ptr95[3..][0..dest_len]; +} +fn fn1591() void { + dest_end = 3; + _ = src_ptr95[0..dest_end :1]; +} +fn fn1592() void { + dest_len = 3; + _ = src_ptr95[0..][0..dest_len :1]; +} +fn fn1593() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr95[1..dest_end :1]; +} +fn fn1594() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr95[1..][0..dest_len :1]; +} +const src_mem78: [3]u8 = .{ 1, 1, 0 }; +var src_ptr96: *const [2:0]u8 = src_mem78[0..2 :0]; +fn fn1595() void { + _ = src_ptr96[1..][0..dest_len]; +} +fn fn1596() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr96[3..dest_end]; +} +fn fn1597() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr96[3..][0..dest_len]; +} +fn fn1598() void { + dest_len = 1; + _ = src_ptr96[3..][0..dest_len]; +} +fn fn1599() void { + expect_id = .mismatched_sentinel; + _ = src_ptr96[0.. :1]; +} +fn fn1600() void { + _ = src_ptr96[0..2 :1]; +} +fn fn1601() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr96[0..dest_end :1]; +} +fn fn1602() void { + expect_id = .mismatched_sentinel; + _ = src_ptr96[0..][0..2 :1]; +} +fn fn1603() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr96[0..][0..dest_len :1]; +} +fn fn1604() void { + expect_id = .mismatched_sentinel; + _ = src_ptr96[1.. :1]; +} +fn fn1605() void { + _ = src_ptr96[1..2 :1]; +} +fn fn1606() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr96[1..dest_end :1]; +} +fn fn1607() void { + expect_id = .mismatched_sentinel; + _ = src_ptr96[1..][0..1 :1]; +} +fn fn1608() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr96[1..][0..dest_len :1]; +} +fn fn1609() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr96[1..][0..dest_len :1]; +} +const src_mem79: [1]u8 = .{1}; +var src_ptr97: *const [1]u8 = src_mem79[0..1]; +fn fn1610() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr97[0..dest_end]; +} +fn fn1611() void { + dest_len = 3; + _ = src_ptr97[0..][0..dest_len]; +} +fn fn1612() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr97[1..dest_end]; +} +fn fn1613() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr97[1..][0..dest_len]; +} +fn fn1614() void { + dest_len = 1; + _ = src_ptr97[1..][0..dest_len]; +} +fn fn1615() void { + _ = src_ptr97[0..dest_end :1]; +} +fn fn1616() void { + dest_end = 1; + _ = src_ptr97[0..dest_end :1]; +} +fn fn1617() void { + dest_len = 3; + _ = src_ptr97[0..][0..dest_len :1]; +} +fn fn1618() void { + dest_len = 1; + _ = src_ptr97[0..][0..dest_len :1]; +} +const src_mem80: [1]u8 = .{0}; +var src_ptr98: *const [0:0]u8 = src_mem80[0..0 :0]; +fn fn1619() void { + dest_end = 3; + _ = src_ptr98[0..dest_end]; +} +fn fn1620() void { + dest_len = 3; + _ = src_ptr98[0..][0..dest_len]; +} +fn fn1621() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr98[1..dest_end]; +} +fn fn1622() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr98[1..][0..dest_len]; +} +fn fn1623() void { + dest_len = 1; + _ = src_ptr98[1..][0..dest_len]; +} +fn fn1624() void { + expect_id = .mismatched_sentinel; + _ = src_ptr98[0.. :1]; +} +fn fn1625() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr98[0..dest_end :1]; +} +fn fn1626() void { + dest_end = 1; + _ = src_ptr98[0..dest_end :1]; +} +fn fn1627() void { + dest_len = 3; + _ = src_ptr98[0..][0..dest_len :1]; +} +fn fn1628() void { + dest_len = 1; + _ = src_ptr98[0..][0..dest_len :1]; +} +const src_mem81: [2]u8 = .{ 1, 1 }; +const src_ptr99: []const u8 = src_mem81[0..2]; +fn fn1629() void { + dest_end = 3; + _ = src_ptr99[0..dest_end]; +} +fn fn1630() void { + dest_len = 3; + _ = src_ptr99[0..][0..dest_len]; +} +fn fn1631() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr99[1..dest_end]; +} +fn fn1632() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr99[1..][0..dest_len]; +} +fn fn1633() void { + _ = src_ptr99[0..dest_end :1]; +} +fn fn1634() void { + _ = src_ptr99[0..][0..dest_len :1]; +} +fn fn1635() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr99[1..dest_end :1]; +} +fn fn1636() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr99[1..][0..dest_len :1]; +} +fn fn1637() void { + dest_len = 1; + _ = src_ptr99[1..][0..dest_len :1]; +} +const src_mem82: [2]u8 = .{ 1, 0 }; +const src_ptr100: [:0]const u8 = src_mem82[0..1 :0]; +fn fn1638() void { + _ = src_ptr100[0..dest_end]; +} +fn fn1639() void { + dest_len = 3; + _ = src_ptr100[0..][0..dest_len]; +} +fn fn1640() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr100[1..dest_end]; +} +fn fn1641() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr100[1..][0..dest_len]; +} +fn fn1642() void { + _ = src_ptr100[0..dest_end :1]; +} +fn fn1643() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr100[0..dest_end :1]; +} +fn fn1644() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr100[0..][0..dest_len :1]; +} +fn fn1645() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr100[0..][0..dest_len :1]; +} +fn fn1646() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr100[1..dest_end :1]; +} +fn fn1647() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr100[1..dest_end :1]; +} +fn fn1648() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr100[1..][0..dest_len :1]; +} +fn fn1649() void { + dest_len = 1; + _ = src_ptr100[1..][0..dest_len :1]; +} +const src_mem83: [3]u8 = .{ 1, 1, 1 }; +const src_ptr101: []const u8 = src_mem83[0..3]; +fn fn1650() void { + dest_len = 3; + _ = src_ptr101[1..][0..dest_len]; +} +fn fn1651() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr101[3..dest_end]; +} +fn fn1652() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr101[3..][0..dest_len]; +} +fn fn1653() void { + dest_len = 1; + _ = src_ptr101[3..][0..dest_len]; +} +fn fn1654() void { + dest_end = 3; + _ = src_ptr101[0..dest_end :1]; +} +fn fn1655() void { + dest_len = 3; + _ = src_ptr101[0..][0..dest_len :1]; +} +fn fn1656() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr101[1..dest_end :1]; +} +fn fn1657() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr101[1..][0..dest_len :1]; +} +const src_mem84: [3]u8 = .{ 1, 1, 0 }; +const src_ptr102: [:0]const u8 = src_mem84[0..2 :0]; +fn fn1658() void { + _ = src_ptr102[1..][0..dest_len]; +} +fn fn1659() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 1; + _ = src_ptr102[3..dest_end]; +} +fn fn1660() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr102[3..][0..dest_len]; +} +fn fn1661() void { + dest_len = 1; + _ = src_ptr102[3..][0..dest_len]; +} +fn fn1662() void { + dest_end = 3; + _ = src_ptr102[0..dest_end :1]; +} +fn fn1663() void { + dest_len = 3; + _ = src_ptr102[0..][0..dest_len :1]; +} +fn fn1664() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr102[1..dest_end :1]; +} +fn fn1665() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr102[1..][0..dest_len :1]; +} +fn fn1666() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr102[1..][0..dest_len :1]; +} +const src_mem85: [1]u8 = .{1}; +const src_ptr103: []const u8 = src_mem85[0..1]; +fn fn1667() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr103[0..dest_end]; +} +fn fn1668() void { + dest_len = 3; + _ = src_ptr103[0..][0..dest_len]; +} +fn fn1669() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr103[1..dest_end]; +} +fn fn1670() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr103[1..][0..dest_len]; +} +fn fn1671() void { + dest_len = 1; + _ = src_ptr103[1..][0..dest_len]; +} +fn fn1672() void { + _ = src_ptr103[0..dest_end :1]; +} +fn fn1673() void { + dest_end = 1; + _ = src_ptr103[0..dest_end :1]; +} +fn fn1674() void { + dest_len = 3; + _ = src_ptr103[0..][0..dest_len :1]; +} +fn fn1675() void { + dest_len = 1; + _ = src_ptr103[0..][0..dest_len :1]; +} +const src_mem86: [1]u8 = .{0}; +const src_ptr104: [:0]const u8 = src_mem86[0..0 :0]; +fn fn1676() void { + dest_end = 3; + _ = src_ptr104[0..dest_end]; +} +fn fn1677() void { + dest_len = 3; + _ = src_ptr104[0..][0..dest_len]; +} +fn fn1678() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr104[1..dest_end]; +} +fn fn1679() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr104[1..][0..dest_len]; +} +fn fn1680() void { + dest_len = 1; + _ = src_ptr104[1..][0..dest_len]; +} +fn fn1681() void { + _ = src_ptr104[0..dest_end :1]; +} +fn fn1682() void { + dest_end = 1; + _ = src_ptr104[0..dest_end :1]; +} +fn fn1683() void { + dest_len = 3; + _ = src_ptr104[0..][0..dest_len :1]; +} +fn fn1684() void { + dest_len = 1; + _ = src_ptr104[0..][0..dest_len :1]; +} +const src_mem87: [2]u8 = .{ 1, 1 }; +var src_ptr105: []const u8 = src_mem87[0..2]; +fn fn1685() void { + _ = src_ptr105[0..3]; +} +fn fn1686() void { + dest_end = 3; + _ = src_ptr105[0..dest_end]; +} +fn fn1687() void { + _ = src_ptr105[0..][0..3]; +} +fn fn1688() void { + dest_len = 3; + _ = src_ptr105[0..][0..dest_len]; +} +fn fn1689() void { + _ = src_ptr105[1..3]; +} +fn fn1690() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr105[1..dest_end]; +} +fn fn1691() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr105[1..][0..2]; +} +fn fn1692() void { + _ = src_ptr105[1..][0..3]; +} +fn fn1693() void { + _ = src_ptr105[1..][0..dest_len]; +} +fn fn1694() void { + expect_id = .accessed_out_of_order; + _ = src_ptr105[3..]; +} +fn fn1695() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr105[3..3]; +} +fn fn1696() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr105[3..dest_end]; +} +fn fn1697() void { + dest_end = 1; + _ = src_ptr105[3..dest_end]; +} +fn fn1698() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr105[3..][0..2]; +} +fn fn1699() void { + _ = src_ptr105[3..][0..3]; +} +fn fn1700() void { + _ = src_ptr105[3..][0..1]; +} +fn fn1701() void { + _ = src_ptr105[3..][0..dest_len]; +} +fn fn1702() void { + dest_len = 1; + _ = src_ptr105[3..][0..dest_len]; +} +fn fn1703() void { + _ = src_ptr105[0..2 :1]; +} +fn fn1704() void { + _ = src_ptr105[0..3 :1]; +} +fn fn1705() void { + dest_end = 3; + _ = src_ptr105[0..dest_end :1]; +} +fn fn1706() void { + _ = src_ptr105[0..][0..2 :1]; +} +fn fn1707() void { + _ = src_ptr105[0..][0..3 :1]; +} +fn fn1708() void { + dest_len = 3; + _ = src_ptr105[0..][0..dest_len :1]; +} +fn fn1709() void { + _ = src_ptr105[1..2 :1]; +} +fn fn1710() void { + _ = src_ptr105[1..3 :1]; +} +fn fn1711() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr105[1..dest_end :1]; +} +fn fn1712() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr105[1..][0..2 :1]; +} +fn fn1713() void { + _ = src_ptr105[1..][0..3 :1]; +} +fn fn1714() void { + _ = src_ptr105[1..][0..1 :1]; +} +fn fn1715() void { + _ = src_ptr105[1..][0..dest_len :1]; +} +fn fn1716() void { + dest_len = 1; + _ = src_ptr105[1..][0..dest_len :1]; +} +fn fn1717() void { + _ = src_ptr105[3..3 :1]; +} +fn fn1718() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr105[3..dest_end :1]; +} +fn fn1719() void { + dest_end = 1; + _ = src_ptr105[3..dest_end :1]; +} +fn fn1720() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr105[3..][0..2 :1]; +} +fn fn1721() void { + _ = src_ptr105[3..][0..3 :1]; +} +fn fn1722() void { + _ = src_ptr105[3..][0..1 :1]; +} +fn fn1723() void { + dest_len = 3; + _ = src_ptr105[3..][0..dest_len :1]; +} +fn fn1724() void { + dest_len = 1; + _ = src_ptr105[3..][0..dest_len :1]; +} +const src_mem88: [2]u8 = .{ 1, 0 }; +var src_ptr106: [:0]const u8 = src_mem88[0..1 :0]; +fn fn1725() void { + _ = src_ptr106[0..3]; +} +fn fn1726() void { + dest_end = 3; + _ = src_ptr106[0..dest_end]; +} +fn fn1727() void { + _ = src_ptr106[0..][0..3]; +} +fn fn1728() void { + dest_len = 3; + _ = src_ptr106[0..][0..dest_len]; +} +fn fn1729() void { + _ = src_ptr106[1..3]; +} +fn fn1730() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr106[1..dest_end]; +} +fn fn1731() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[1..][0..2]; +} +fn fn1732() void { + _ = src_ptr106[1..][0..3]; +} +fn fn1733() void { + _ = src_ptr106[1..][0..dest_len]; +} +fn fn1734() void { + expect_id = .accessed_out_of_order; + _ = src_ptr106[3..]; +} +fn fn1735() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[3..3]; +} +fn fn1736() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr106[3..dest_end]; +} +fn fn1737() void { + dest_end = 1; + _ = src_ptr106[3..dest_end]; +} +fn fn1738() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[3..][0..2]; +} +fn fn1739() void { + _ = src_ptr106[3..][0..3]; +} +fn fn1740() void { + _ = src_ptr106[3..][0..1]; +} +fn fn1741() void { + _ = src_ptr106[3..][0..dest_len]; +} +fn fn1742() void { + dest_len = 1; + _ = src_ptr106[3..][0..dest_len]; +} +fn fn1743() void { + expect_id = .mismatched_sentinel; + _ = src_ptr106[0.. :1]; +} +fn fn1744() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[0..2 :1]; +} +fn fn1745() void { + _ = src_ptr106[0..3 :1]; +} +fn fn1746() void { + expect_id = .mismatched_sentinel; + _ = src_ptr106[0..1 :1]; +} +fn fn1747() void { + expect_id = .accessed_out_of_bounds; + dest_end = 3; + _ = src_ptr106[0..dest_end :1]; +} +fn fn1748() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr106[0..dest_end :1]; +} +fn fn1749() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[0..][0..2 :1]; +} +fn fn1750() void { + _ = src_ptr106[0..][0..3 :1]; +} +fn fn1751() void { + expect_id = .mismatched_sentinel; + _ = src_ptr106[0..][0..1 :1]; +} +fn fn1752() void { + expect_id = .accessed_out_of_bounds; + dest_len = 3; + _ = src_ptr106[0..][0..dest_len :1]; +} +fn fn1753() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr106[0..][0..dest_len :1]; +} +fn fn1754() void { + _ = src_ptr106[1.. :1]; +} +fn fn1755() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[1..2 :1]; +} +fn fn1756() void { + _ = src_ptr106[1..3 :1]; +} +fn fn1757() void { + expect_id = .mismatched_sentinel; + _ = src_ptr106[1..1 :1]; +} +fn fn1758() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr106[1..dest_end :1]; +} +fn fn1759() void { + expect_id = .mismatched_sentinel; + dest_end = 1; + _ = src_ptr106[1..dest_end :1]; +} +fn fn1760() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[1..][0..2 :1]; +} +fn fn1761() void { + _ = src_ptr106[1..][0..3 :1]; +} +fn fn1762() void { + _ = src_ptr106[1..][0..1 :1]; +} +fn fn1763() void { + dest_len = 3; + _ = src_ptr106[1..][0..dest_len :1]; +} +fn fn1764() void { + dest_len = 1; + _ = src_ptr106[1..][0..dest_len :1]; +} +fn fn1765() void { + expect_id = .accessed_out_of_order; + _ = src_ptr106[3.. :1]; +} +fn fn1766() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[3..3 :1]; +} +fn fn1767() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr106[3..dest_end :1]; +} +fn fn1768() void { + dest_end = 1; + _ = src_ptr106[3..dest_end :1]; +} +fn fn1769() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr106[3..][0..2 :1]; +} +fn fn1770() void { + _ = src_ptr106[3..][0..3 :1]; +} +fn fn1771() void { + _ = src_ptr106[3..][0..1 :1]; +} +fn fn1772() void { + dest_len = 3; + _ = src_ptr106[3..][0..dest_len :1]; +} +fn fn1773() void { + dest_len = 1; + _ = src_ptr106[3..][0..dest_len :1]; +} +const src_mem89: [3]u8 = .{ 1, 1, 1 }; +var src_ptr107: []const u8 = src_mem89[0..3]; +fn fn1774() void { + _ = src_ptr107[1..][0..3]; +} +fn fn1775() void { + dest_len = 3; + _ = src_ptr107[1..][0..dest_len]; +} +fn fn1776() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr107[3..dest_end]; +} +fn fn1777() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr107[3..][0..2]; +} +fn fn1778() void { + _ = src_ptr107[3..][0..3]; +} +fn fn1779() void { + _ = src_ptr107[3..][0..1]; +} +fn fn1780() void { + _ = src_ptr107[3..][0..dest_len]; +} +fn fn1781() void { + dest_len = 1; + _ = src_ptr107[3..][0..dest_len]; +} +fn fn1782() void { + _ = src_ptr107[0..3 :1]; +} +fn fn1783() void { + dest_end = 3; + _ = src_ptr107[0..dest_end :1]; +} +fn fn1784() void { + _ = src_ptr107[0..][0..3 :1]; +} +fn fn1785() void { + dest_len = 3; + _ = src_ptr107[0..][0..dest_len :1]; +} +fn fn1786() void { + _ = src_ptr107[1..3 :1]; +} +fn fn1787() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr107[1..dest_end :1]; +} +fn fn1788() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr107[1..][0..2 :1]; +} +fn fn1789() void { + _ = src_ptr107[1..][0..3 :1]; +} +fn fn1790() void { + _ = src_ptr107[1..][0..dest_len :1]; +} +fn fn1791() void { + _ = src_ptr107[3..3 :1]; +} +fn fn1792() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr107[3..dest_end :1]; +} +fn fn1793() void { + dest_end = 1; + _ = src_ptr107[3..dest_end :1]; +} +fn fn1794() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr107[3..][0..2 :1]; +} +fn fn1795() void { + _ = src_ptr107[3..][0..3 :1]; +} +fn fn1796() void { + _ = src_ptr107[3..][0..1 :1]; +} +fn fn1797() void { + _ = src_ptr107[3..][0..dest_len :1]; +} +fn fn1798() void { + dest_len = 1; + _ = src_ptr107[3..][0..dest_len :1]; +} +const src_mem90: [3]u8 = .{ 1, 1, 0 }; +var src_ptr108: [:0]const u8 = src_mem90[0..2 :0]; +fn fn1799() void { + _ = src_ptr108[1..][0..3]; +} +fn fn1800() void { + dest_len = 3; + _ = src_ptr108[1..][0..dest_len]; +} +fn fn1801() void { + expect_id = .accessed_out_of_order; + _ = src_ptr108[3..]; +} +fn fn1802() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr108[3..dest_end]; +} +fn fn1803() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[3..][0..2]; +} +fn fn1804() void { + _ = src_ptr108[3..][0..3]; +} +fn fn1805() void { + _ = src_ptr108[3..][0..1]; +} +fn fn1806() void { + _ = src_ptr108[3..][0..dest_len]; +} +fn fn1807() void { + dest_len = 1; + _ = src_ptr108[3..][0..dest_len]; +} +fn fn1808() void { + expect_id = .mismatched_sentinel; + _ = src_ptr108[0.. :1]; +} +fn fn1809() void { + _ = src_ptr108[0..2 :1]; +} +fn fn1810() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[0..3 :1]; +} +fn fn1811() void { + dest_end = 3; + _ = src_ptr108[0..dest_end :1]; +} +fn fn1812() void { + expect_id = .mismatched_sentinel; + _ = src_ptr108[0..][0..2 :1]; +} +fn fn1813() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[0..][0..3 :1]; +} +fn fn1814() void { + dest_len = 3; + _ = src_ptr108[0..][0..dest_len :1]; +} +fn fn1815() void { + expect_id = .mismatched_sentinel; + _ = src_ptr108[1.. :1]; +} +fn fn1816() void { + _ = src_ptr108[1..2 :1]; +} +fn fn1817() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[1..3 :1]; +} +fn fn1818() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr108[1..dest_end :1]; +} +fn fn1819() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[1..][0..2 :1]; +} +fn fn1820() void { + _ = src_ptr108[1..][0..3 :1]; +} +fn fn1821() void { + expect_id = .mismatched_sentinel; + _ = src_ptr108[1..][0..1 :1]; +} +fn fn1822() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[1..][0..dest_len :1]; +} +fn fn1823() void { + expect_id = .mismatched_sentinel; + dest_len = 1; + _ = src_ptr108[1..][0..dest_len :1]; +} +fn fn1824() void { + expect_id = .accessed_out_of_order; + _ = src_ptr108[3.. :1]; +} +fn fn1825() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[3..3 :1]; +} +fn fn1826() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr108[3..dest_end :1]; +} +fn fn1827() void { + dest_end = 1; + _ = src_ptr108[3..dest_end :1]; +} +fn fn1828() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr108[3..][0..2 :1]; +} +fn fn1829() void { + _ = src_ptr108[3..][0..3 :1]; +} +fn fn1830() void { + _ = src_ptr108[3..][0..1 :1]; +} +fn fn1831() void { + dest_len = 3; + _ = src_ptr108[3..][0..dest_len :1]; +} +fn fn1832() void { + dest_len = 1; + _ = src_ptr108[3..][0..dest_len :1]; +} +const src_mem91: [1]u8 = .{1}; +var src_ptr109: []const u8 = src_mem91[0..1]; +fn fn1833() void { + _ = src_ptr109[0..2]; +} +fn fn1834() void { + _ = src_ptr109[0..3]; +} +fn fn1835() void { + dest_end = 3; + _ = src_ptr109[0..dest_end]; +} +fn fn1836() void { + _ = src_ptr109[0..][0..2]; +} +fn fn1837() void { + _ = src_ptr109[0..][0..3]; +} +fn fn1838() void { + dest_len = 3; + _ = src_ptr109[0..][0..dest_len]; +} +fn fn1839() void { + _ = src_ptr109[1..2]; +} +fn fn1840() void { + _ = src_ptr109[1..3]; +} +fn fn1841() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr109[1..dest_end]; +} +fn fn1842() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr109[1..][0..2]; +} +fn fn1843() void { + _ = src_ptr109[1..][0..3]; +} +fn fn1844() void { + _ = src_ptr109[1..][0..1]; +} +fn fn1845() void { + _ = src_ptr109[1..][0..dest_len]; +} +fn fn1846() void { + dest_len = 1; + _ = src_ptr109[1..][0..dest_len]; +} +fn fn1847() void { + expect_id = .accessed_out_of_order; + _ = src_ptr109[3..]; +} +fn fn1848() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr109[3..3]; +} +fn fn1849() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr109[3..dest_end]; +} +fn fn1850() void { + dest_end = 1; + _ = src_ptr109[3..dest_end]; +} +fn fn1851() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr109[3..][0..2]; +} +fn fn1852() void { + _ = src_ptr109[3..][0..3]; +} +fn fn1853() void { + _ = src_ptr109[3..][0..1]; +} +fn fn1854() void { + dest_len = 3; + _ = src_ptr109[3..][0..dest_len]; +} +fn fn1855() void { + dest_len = 1; + _ = src_ptr109[3..][0..dest_len]; +} +fn fn1856() void { + _ = src_ptr109[0..2 :1]; +} +fn fn1857() void { + _ = src_ptr109[0..3 :1]; +} +fn fn1858() void { + _ = src_ptr109[0..1 :1]; +} +fn fn1859() void { + dest_end = 3; + _ = src_ptr109[0..dest_end :1]; +} +fn fn1860() void { + dest_end = 1; + _ = src_ptr109[0..dest_end :1]; +} +fn fn1861() void { + _ = src_ptr109[0..][0..2 :1]; +} +fn fn1862() void { + _ = src_ptr109[0..][0..3 :1]; +} +fn fn1863() void { + _ = src_ptr109[0..][0..1 :1]; +} +fn fn1864() void { + dest_len = 3; + _ = src_ptr109[0..][0..dest_len :1]; +} +fn fn1865() void { + dest_len = 1; + _ = src_ptr109[0..][0..dest_len :1]; +} +fn fn1866() void { + _ = src_ptr109[1..2 :1]; +} +fn fn1867() void { + _ = src_ptr109[1..3 :1]; +} +fn fn1868() void { + _ = src_ptr109[1..1 :1]; +} +fn fn1869() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr109[1..dest_end :1]; +} +fn fn1870() void { + dest_end = 1; + _ = src_ptr109[1..dest_end :1]; +} +fn fn1871() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr109[1..][0..2 :1]; +} +fn fn1872() void { + _ = src_ptr109[1..][0..3 :1]; +} +fn fn1873() void { + _ = src_ptr109[1..][0..1 :1]; +} +fn fn1874() void { + dest_len = 3; + _ = src_ptr109[1..][0..dest_len :1]; +} +fn fn1875() void { + dest_len = 1; + _ = src_ptr109[1..][0..dest_len :1]; +} +fn fn1876() void { + _ = src_ptr109[3..3 :1]; +} +fn fn1877() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr109[3..dest_end :1]; +} +fn fn1878() void { + dest_end = 1; + _ = src_ptr109[3..dest_end :1]; +} +fn fn1879() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr109[3..][0..2 :1]; +} +fn fn1880() void { + _ = src_ptr109[3..][0..3 :1]; +} +fn fn1881() void { + _ = src_ptr109[3..][0..1 :1]; +} +fn fn1882() void { + dest_len = 3; + _ = src_ptr109[3..][0..dest_len :1]; +} +fn fn1883() void { + dest_len = 1; + _ = src_ptr109[3..][0..dest_len :1]; +} +const src_mem92: [1]u8 = .{0}; +var src_ptr110: [:0]const u8 = src_mem92[0..0 :0]; +fn fn1884() void { + _ = src_ptr110[0..2]; +} +fn fn1885() void { + _ = src_ptr110[0..3]; +} +fn fn1886() void { + dest_end = 3; + _ = src_ptr110[0..dest_end]; +} +fn fn1887() void { + _ = src_ptr110[0..][0..2]; +} +fn fn1888() void { + _ = src_ptr110[0..][0..3]; +} +fn fn1889() void { + dest_len = 3; + _ = src_ptr110[0..][0..dest_len]; +} +fn fn1890() void { + expect_id = .accessed_out_of_order; + _ = src_ptr110[1..]; +} +fn fn1891() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[1..2]; +} +fn fn1892() void { + _ = src_ptr110[1..3]; +} +fn fn1893() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr110[1..dest_end]; +} +fn fn1894() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[1..][0..2]; +} +fn fn1895() void { + _ = src_ptr110[1..][0..3]; +} +fn fn1896() void { + _ = src_ptr110[1..][0..1]; +} +fn fn1897() void { + _ = src_ptr110[1..][0..dest_len]; +} +fn fn1898() void { + dest_len = 1; + _ = src_ptr110[1..][0..dest_len]; +} +fn fn1899() void { + expect_id = .accessed_out_of_order; + _ = src_ptr110[3..]; +} +fn fn1900() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[3..3]; +} +fn fn1901() void { + expect_id = .accessed_out_of_order_extra; + _ = src_ptr110[3..dest_end]; +} +fn fn1902() void { + dest_end = 1; + _ = src_ptr110[3..dest_end]; +} +fn fn1903() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[3..][0..2]; +} +fn fn1904() void { + _ = src_ptr110[3..][0..3]; +} +fn fn1905() void { + _ = src_ptr110[3..][0..1]; +} +fn fn1906() void { + dest_len = 3; + _ = src_ptr110[3..][0..dest_len]; +} +fn fn1907() void { + dest_len = 1; + _ = src_ptr110[3..][0..dest_len]; +} +fn fn1908() void { + expect_id = .mismatched_sentinel; + _ = src_ptr110[0.. :1]; +} +fn fn1909() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[0..2 :1]; +} +fn fn1910() void { + _ = src_ptr110[0..3 :1]; +} +fn fn1911() void { + _ = src_ptr110[0..1 :1]; +} +fn fn1912() void { + dest_end = 3; + _ = src_ptr110[0..dest_end :1]; +} +fn fn1913() void { + dest_end = 1; + _ = src_ptr110[0..dest_end :1]; +} +fn fn1914() void { + _ = src_ptr110[0..][0..2 :1]; +} +fn fn1915() void { + _ = src_ptr110[0..][0..3 :1]; +} +fn fn1916() void { + _ = src_ptr110[0..][0..1 :1]; +} +fn fn1917() void { + dest_len = 3; + _ = src_ptr110[0..][0..dest_len :1]; +} +fn fn1918() void { + dest_len = 1; + _ = src_ptr110[0..][0..dest_len :1]; +} +fn fn1919() void { + expect_id = .accessed_out_of_order; + _ = src_ptr110[1.. :1]; +} +fn fn1920() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[1..2 :1]; +} +fn fn1921() void { + _ = src_ptr110[1..3 :1]; +} +fn fn1922() void { + _ = src_ptr110[1..1 :1]; +} +fn fn1923() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr110[1..dest_end :1]; +} +fn fn1924() void { + dest_end = 1; + _ = src_ptr110[1..dest_end :1]; +} +fn fn1925() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[1..][0..2 :1]; +} +fn fn1926() void { + _ = src_ptr110[1..][0..3 :1]; +} +fn fn1927() void { + _ = src_ptr110[1..][0..1 :1]; +} +fn fn1928() void { + dest_len = 3; + _ = src_ptr110[1..][0..dest_len :1]; +} +fn fn1929() void { + dest_len = 1; + _ = src_ptr110[1..][0..dest_len :1]; +} +fn fn1930() void { + expect_id = .accessed_out_of_order; + _ = src_ptr110[3.. :1]; +} +fn fn1931() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[3..3 :1]; +} +fn fn1932() void { + expect_id = .accessed_out_of_order_extra; + dest_end = 3; + _ = src_ptr110[3..dest_end :1]; +} +fn fn1933() void { + dest_end = 1; + _ = src_ptr110[3..dest_end :1]; +} +fn fn1934() void { + expect_id = .accessed_out_of_bounds; + _ = src_ptr110[3..][0..2 :1]; +} +fn fn1935() void { + _ = src_ptr110[3..][0..3 :1]; +} +fn fn1936() void { + _ = src_ptr110[3..][0..1 :1]; +} +fn fn1937() void { + dest_len = 3; + _ = src_ptr110[3..][0..dest_len :1]; +} +fn fn1938() void { + dest_len = 1; + _ = src_ptr110[3..][0..dest_len :1]; +} +const src_mem93: [2]u8 = .{ 1, 0 }; +const src_ptr111: [*:0]const u8 = @ptrCast(&src_mem93); +fn fn1939() void { + expect_id = .mismatched_sentinel; + _ = src_ptr111[0..dest_end :1]; +} +fn fn1940() void { + _ = src_ptr111[0..][0..dest_len :1]; +} +fn fn1941() void { + _ = src_ptr111[1..dest_end :1]; +} +const src_mem94: [3]u8 = .{ 1, 1, 0 }; +const src_ptr112: [*:0]const u8 = @ptrCast(&src_mem94); +fn fn1942() void { + _ = src_ptr112[1..][0..dest_len :1]; +} +const src_mem95: [2]u8 = .{ 1, 0 }; +var src_ptr113: [*:0]const u8 = @ptrCast(&src_mem95); +fn fn1943() void { + _ = src_ptr113[0..1 :1]; +} +fn fn1944() void { + _ = src_ptr113[0..dest_end :1]; +} +fn fn1945() void { + _ = src_ptr113[0..][0..1 :1]; +} +fn fn1946() void { + _ = src_ptr113[0..][0..dest_len :1]; +} +fn fn1947() void { + _ = src_ptr113[1..1 :1]; +} +fn fn1948() void { + _ = src_ptr113[1..dest_end :1]; +} +const src_mem96: [3]u8 = .{ 1, 1, 0 }; +var src_ptr114: [*:0]const u8 = @ptrCast(&src_mem96); +fn fn1949() void { + _ = src_ptr114[0..2 :1]; +} +fn fn1950() void { + _ = src_ptr114[0..][0..2 :1]; +} +fn fn1951() void { + _ = src_ptr114[1..2 :1]; +} +fn fn1952() void { + _ = src_ptr114[1..][0..1 :1]; +} +fn fn1953() void { + _ = src_ptr114[1..][0..dest_len :1]; +} +var src_ptr115: [*c]const u8 = null; +fn fn1954() void { + expect_id = .accessed_null_value; + _ = src_ptr115[0..]; +} +fn fn1955() void { + _ = src_ptr115[0..2]; +} +fn fn1956() void { + _ = src_ptr115[0..3]; +} +fn fn1957() void { + _ = src_ptr115[0..1]; +} +fn fn1958() void { + dest_end = 3; + _ = src_ptr115[0..dest_end]; +} +fn fn1959() void { + dest_end = 1; + _ = src_ptr115[0..dest_end]; +} +fn fn1960() void { + _ = src_ptr115[0..][0..2]; +} +fn fn1961() void { + _ = src_ptr115[0..][0..3]; +} +fn fn1962() void { + _ = src_ptr115[0..][0..1]; +} +fn fn1963() void { + dest_len = 3; + _ = src_ptr115[0..][0..dest_len]; +} +fn fn1964() void { + dest_len = 1; + _ = src_ptr115[0..][0..dest_len]; +} +fn fn1965() void { + _ = src_ptr115[1..]; +} +fn fn1966() void { + _ = src_ptr115[1..2]; +} +fn fn1967() void { + _ = src_ptr115[1..3]; +} +fn fn1968() void { + _ = src_ptr115[1..1]; +} +fn fn1969() void { + dest_end = 3; + _ = src_ptr115[1..dest_end]; +} +fn fn1970() void { + dest_end = 1; + _ = src_ptr115[1..dest_end]; +} +fn fn1971() void { + _ = src_ptr115[1..][0..2]; +} +fn fn1972() void { + _ = src_ptr115[1..][0..3]; +} +fn fn1973() void { + _ = src_ptr115[1..][0..1]; +} +fn fn1974() void { + dest_len = 3; + _ = src_ptr115[1..][0..dest_len]; +} +fn fn1975() void { + dest_len = 1; + _ = src_ptr115[1..][0..dest_len]; +} +fn fn1976() void { + _ = src_ptr115[3..]; +} +fn fn1977() void { + _ = src_ptr115[3..3]; +} +fn fn1978() void { + dest_end = 3; + _ = src_ptr115[3..dest_end]; +} +fn fn1979() void { + _ = src_ptr115[3..][0..2]; +} +fn fn1980() void { + _ = src_ptr115[3..][0..3]; +} +fn fn1981() void { + _ = src_ptr115[3..][0..1]; +} +fn fn1982() void { + dest_len = 3; + _ = src_ptr115[3..][0..dest_len]; +} +fn fn1983() void { + dest_len = 1; + _ = src_ptr115[3..][0..dest_len]; +} +fn fn1984() void { + _ = src_ptr115[0.. :1]; +} +fn fn1985() void { + _ = src_ptr115[0..2 :1]; +} +fn fn1986() void { + _ = src_ptr115[0..3 :1]; +} +fn fn1987() void { + _ = src_ptr115[0..1 :1]; +} +fn fn1988() void { + _ = src_ptr115[0..dest_end :1]; +} +fn fn1989() void { + dest_end = 1; + _ = src_ptr115[0..dest_end :1]; +} +fn fn1990() void { + _ = src_ptr115[0..][0..2 :1]; +} +fn fn1991() void { + _ = src_ptr115[0..][0..3 :1]; +} +fn fn1992() void { + _ = src_ptr115[0..][0..1 :1]; +} +fn fn1993() void { + dest_len = 3; + _ = src_ptr115[0..][0..dest_len :1]; +} +fn fn1994() void { + dest_len = 1; + _ = src_ptr115[0..][0..dest_len :1]; +} +fn fn1995() void { + _ = src_ptr115[1.. :1]; +} +fn fn1996() void { + _ = src_ptr115[1..2 :1]; +} +fn fn1997() void { + _ = src_ptr115[1..3 :1]; +} +fn fn1998() void { + _ = src_ptr115[1..1 :1]; +} +fn fn1999() void { + dest_end = 3; + _ = src_ptr115[1..dest_end :1]; +} +fn fn2000() void { + dest_end = 1; + _ = src_ptr115[1..dest_end :1]; +} +fn fn2001() void { + _ = src_ptr115[1..][0..2 :1]; +} +fn fn2002() void { + _ = src_ptr115[1..][0..3 :1]; +} +fn fn2003() void { + _ = src_ptr115[1..][0..1 :1]; +} +fn fn2004() void { + dest_len = 3; + _ = src_ptr115[1..][0..dest_len :1]; +} +fn fn2005() void { + dest_len = 1; + _ = src_ptr115[1..][0..dest_len :1]; +} +fn fn2006() void { + _ = src_ptr115[3.. :1]; +} +fn fn2007() void { + _ = src_ptr115[3..3 :1]; +} +fn fn2008() void { + dest_end = 3; + _ = src_ptr115[3..dest_end :1]; +} +fn fn2009() void { + _ = src_ptr115[3..][0..2 :1]; +} +fn fn2010() void { + _ = src_ptr115[3..][0..3 :1]; +} +fn fn2011() void { + _ = src_ptr115[3..][0..1 :1]; +} +fn fn2012() void { + dest_len = 3; + _ = src_ptr115[3..][0..dest_len :1]; +} +fn fn2013() void { + dest_len = 1; + _ = src_ptr115[3..][0..dest_len :1]; +} +const test_fns: []const *const fn () void = &.{ + fn0, + fn1, + fn2, + fn3, + fn4, + fn5, + fn6, + fn7, + fn8, + fn9, + fn10, + fn11, + fn12, + fn13, + fn14, + fn15, + fn16, + fn17, + fn18, + fn19, + fn20, + fn21, + fn22, + fn23, + fn24, + fn25, + fn26, + fn27, + fn28, + fn29, + fn30, + fn31, + fn32, + fn33, + fn34, + fn35, + fn36, + fn37, + fn38, + fn39, + fn40, + fn41, + fn42, + fn43, + fn44, + fn45, + fn46, + fn47, + fn48, + fn49, + fn50, + fn51, + fn52, + fn53, + fn54, + fn55, + fn56, + fn57, + fn58, + fn59, + fn60, + fn61, + fn62, + fn63, + fn64, + fn65, + fn66, + fn67, + fn68, + fn69, + fn70, + fn71, + fn72, + fn73, + fn74, + fn75, + fn76, + fn77, + fn78, + fn79, + fn80, + fn81, + fn82, + fn83, + fn84, + fn85, + fn86, + fn87, + fn88, + fn89, + fn90, + fn91, + fn92, + fn93, + fn94, + fn95, + fn96, + fn97, + fn98, + fn99, + fn100, + fn101, + fn102, + fn103, + fn104, + fn105, + fn106, + fn107, + fn108, + fn109, + fn110, + fn111, + fn112, + fn113, + fn114, + fn115, + fn116, + fn117, + fn118, + fn119, + fn120, + fn121, + fn122, + fn123, + fn124, + fn125, + fn126, + fn127, + fn128, + fn129, + fn130, + fn131, + fn132, + fn133, + fn134, + fn135, + fn136, + fn137, + fn138, + fn139, + fn140, + fn141, + fn142, + fn143, + fn144, + fn145, + fn146, + fn147, + fn148, + fn149, + fn150, + fn151, + fn152, + fn153, + fn154, + fn155, + fn156, + fn157, + fn158, + fn159, + fn160, + fn161, + fn162, + fn163, + fn164, + fn165, + fn166, + fn167, + fn168, + fn169, + fn170, + fn171, + fn172, + fn173, + fn174, + fn175, + fn176, + fn177, + fn178, + fn179, + fn180, + fn181, + fn182, + fn183, + fn184, + fn185, + fn186, + fn187, + fn188, + fn189, + fn190, + fn191, + fn192, + fn193, + fn194, + fn195, + fn196, + fn197, + fn198, + fn199, + fn200, + fn201, + fn202, + fn203, + fn204, + fn205, + fn206, + fn207, + fn208, + fn209, + fn210, + fn211, + fn212, + fn213, + fn214, + fn215, + fn216, + fn217, + fn218, + fn219, + fn220, + fn221, + fn222, + fn223, + fn224, + fn225, + fn226, + fn227, + fn228, + fn229, + fn230, + fn231, + fn232, + fn233, + fn234, + fn235, + fn236, + fn237, + fn238, + fn239, + fn240, + fn241, + fn242, + fn243, + fn244, + fn245, + fn246, + fn247, + fn248, + fn249, + fn250, + fn251, + fn252, + fn253, + fn254, + fn255, + fn256, + fn257, + fn258, + fn259, + fn260, + fn261, + fn262, + fn263, + fn264, + fn265, + fn266, + fn267, + fn268, + fn269, + fn270, + fn271, + fn272, + fn273, + fn274, + fn275, + fn276, + fn277, + fn278, + fn279, + fn280, + fn281, + fn282, + fn283, + fn284, + fn285, + fn286, + fn287, + fn288, + fn289, + fn290, + fn291, + fn292, + fn293, + fn294, + fn295, + fn296, + fn297, + fn298, + fn299, + fn300, + fn301, + fn302, + fn303, + fn304, + fn305, + fn306, + fn307, + fn308, + fn309, + fn310, + fn311, + fn312, + fn313, + fn314, + fn315, + fn316, + fn317, + fn318, + fn319, + fn320, + fn321, + fn322, + fn323, + fn324, + fn325, + fn326, + fn327, + fn328, + fn329, + fn330, + fn331, + fn332, + fn333, + fn334, + fn335, + fn336, + fn337, + fn338, + fn339, + fn340, + fn341, + fn342, + fn343, + fn344, + fn345, + fn346, + fn347, + fn348, + fn349, + fn350, + fn351, + fn352, + fn353, + fn354, + fn355, + fn356, + fn357, + fn358, + fn359, + fn360, + fn361, + fn362, + fn363, + fn364, + fn365, + fn366, + fn367, + fn368, + fn369, + fn370, + fn371, + fn372, + fn373, + fn374, + fn375, + fn376, + fn377, + fn378, + fn379, + fn380, + fn381, + fn382, + fn383, + fn384, + fn385, + fn386, + fn387, + fn388, + fn389, + fn390, + fn391, + fn392, + fn393, + fn394, + fn395, + fn396, + fn397, + fn398, + fn399, + fn400, + fn401, + fn402, + fn403, + fn404, + fn405, + fn406, + fn407, + fn408, + fn409, + fn410, + fn411, + fn412, + fn413, + fn414, + fn415, + fn416, + fn417, + fn418, + fn419, + fn420, + fn421, + fn422, + fn423, + fn424, + fn425, + fn426, + fn427, + fn428, + fn429, + fn430, + fn431, + fn432, + fn433, + fn434, + fn435, + fn436, + fn437, + fn438, + fn439, + fn440, + fn441, + fn442, + fn443, + fn444, + fn445, + fn446, + fn447, + fn448, + fn449, + fn450, + fn451, + fn452, + fn453, + fn454, + fn455, + fn456, + fn457, + fn458, + fn459, + fn460, + fn461, + fn462, + fn463, + fn464, + fn465, + fn466, + fn467, + fn468, + fn469, + fn470, + fn471, + fn472, + fn473, + fn474, + fn475, + fn476, + fn477, + fn478, + fn479, + fn480, + fn481, + fn482, + fn483, + fn484, + fn485, + fn486, + fn487, + fn488, + fn489, + fn490, + fn491, + fn492, + fn493, + fn494, + fn495, + fn496, + fn497, + fn498, + fn499, + fn500, + fn501, + fn502, + fn503, + fn504, + fn505, + fn506, + fn507, + fn508, + fn509, + fn510, + fn511, + fn512, + fn513, + fn514, + fn515, + fn516, + fn517, + fn518, + fn519, + fn520, + fn521, + fn522, + fn523, + fn524, + fn525, + fn526, + fn527, + fn528, + fn529, + fn530, + fn531, + fn532, + fn533, + fn534, + fn535, + fn536, + fn537, + fn538, + fn539, + fn540, + fn541, + fn542, + fn543, + fn544, + fn545, + fn546, + fn547, + fn548, + fn549, + fn550, + fn551, + fn552, + fn553, + fn554, + fn555, + fn556, + fn557, + fn558, + fn559, + fn560, + fn561, + fn562, + fn563, + fn564, + fn565, + fn566, + fn567, + fn568, + fn569, + fn570, + fn571, + fn572, + fn573, + fn574, + fn575, + fn576, + fn577, + fn578, + fn579, + fn580, + fn581, + fn582, + fn583, + fn584, + fn585, + fn586, + fn587, + fn588, + fn589, + fn590, + fn591, + fn592, + fn593, + fn594, + fn595, + fn596, + fn597, + fn598, + fn599, + fn600, + fn601, + fn602, + fn603, + fn604, + fn605, + fn606, + fn607, + fn608, + fn609, + fn610, + fn611, + fn612, + fn613, + fn614, + fn615, + fn616, + fn617, + fn618, + fn619, + fn620, + fn621, + fn622, + fn623, + fn624, + fn625, + fn626, + fn627, + fn628, + fn629, + fn630, + fn631, + fn632, + fn633, + fn634, + fn635, + fn636, + fn637, + fn638, + fn639, + fn640, + fn641, + fn642, + fn643, + fn644, + fn645, + fn646, + fn647, + fn648, + fn649, + fn650, + fn651, + fn652, + fn653, + fn654, + fn655, + fn656, + fn657, + fn658, + fn659, + fn660, + fn661, + fn662, + fn663, + fn664, + fn665, + fn666, + fn667, + fn668, + fn669, + fn670, + fn671, + fn672, + fn673, + fn674, + fn675, + fn676, + fn677, + fn678, + fn679, + fn680, + fn681, + fn682, + fn683, + fn684, + fn685, + fn686, + fn687, + fn688, + fn689, + fn690, + fn691, + fn692, + fn693, + fn694, + fn695, + fn696, + fn697, + fn698, + fn699, + fn700, + fn701, + fn702, + fn703, + fn704, + fn705, + fn706, + fn707, + fn708, + fn709, + fn710, + fn711, + fn712, + fn713, + fn714, + fn715, + fn716, + fn717, + fn718, + fn719, + fn720, + fn721, + fn722, + fn723, + fn724, + fn725, + fn726, + fn727, + fn728, + fn729, + fn730, + fn731, + fn732, + fn733, + fn734, + fn735, + fn736, + fn737, + fn738, + fn739, + fn740, + fn741, + fn742, + fn743, + fn744, + fn745, + fn746, + fn747, + fn748, + fn749, + fn750, + fn751, + fn752, + fn753, + fn754, + fn755, + fn756, + fn757, + fn758, + fn759, + fn760, + fn761, + fn762, + fn763, + fn764, + fn765, + fn766, + fn767, + fn768, + fn769, + fn770, + fn771, + fn772, + fn773, + fn774, + fn775, + fn776, + fn777, + fn778, + fn779, + fn780, + fn781, + fn782, + fn783, + fn784, + fn785, + fn786, + fn787, + fn788, + fn789, + fn790, + fn791, + fn792, + fn793, + fn794, + fn795, + fn796, + fn797, + fn798, + fn799, + fn800, + fn801, + fn802, + fn803, + fn804, + fn805, + fn806, + fn807, + fn808, + fn809, + fn810, + fn811, + fn812, + fn813, + fn814, + fn815, + fn816, + fn817, + fn818, + fn819, + fn820, + fn821, + fn822, + fn823, + fn824, + fn825, + fn826, + fn827, + fn828, + fn829, + fn830, + fn831, + fn832, + fn833, + fn834, + fn835, + fn836, + fn837, + fn838, + fn839, + fn840, + fn841, + fn842, + fn843, + fn844, + fn845, + fn846, + fn847, + fn848, + fn849, + fn850, + fn851, + fn852, + fn853, + fn854, + fn855, + fn856, + fn857, + fn858, + fn859, + fn860, + fn861, + fn862, + fn863, + fn864, + fn865, + fn866, + fn867, + fn868, + fn869, + fn870, + fn871, + fn872, + fn873, + fn874, + fn875, + fn876, + fn877, + fn878, + fn879, + fn880, + fn881, + fn882, + fn883, + fn884, + fn885, + fn886, + fn887, + fn888, + fn889, + fn890, + fn891, + fn892, + fn893, + fn894, + fn895, + fn896, + fn897, + fn898, + fn899, + fn900, + fn901, + fn902, + fn903, + fn904, + fn905, + fn906, + fn907, + fn908, + fn909, + fn910, + fn911, + fn912, + fn913, + fn914, + fn915, + fn916, + fn917, + fn918, + fn919, + fn920, + fn921, + fn922, + fn923, + fn924, + fn925, + fn926, + fn927, + fn928, + fn929, + fn930, + fn931, + fn932, + fn933, + fn934, + fn935, + fn936, + fn937, + fn938, + fn939, + fn940, + fn941, + fn942, + fn943, + fn944, + fn945, + fn946, + fn947, + fn948, + fn949, + fn950, + fn951, + fn952, + fn953, + fn954, + fn955, + fn956, + fn957, + fn958, + fn959, + fn960, + fn961, + fn962, + fn963, + fn964, + fn965, + fn966, + fn967, + fn968, + fn969, + fn970, + fn971, + fn972, + fn973, + fn974, + fn975, + fn976, + fn977, + fn978, + fn979, + fn980, + fn981, + fn982, + fn983, + fn984, + fn985, + fn986, + fn987, + fn988, + fn989, + fn990, + fn991, + fn992, + fn993, + fn994, + fn995, + fn996, + fn997, + fn998, + fn999, + fn1000, + fn1001, + fn1002, + fn1003, + fn1004, + fn1005, + fn1006, + fn1007, + fn1008, + fn1009, + fn1010, + fn1011, + fn1012, + fn1013, + fn1014, + fn1015, + fn1016, + fn1017, + fn1018, + fn1019, + fn1020, + fn1021, + fn1022, + fn1023, + fn1024, + fn1025, + fn1026, + fn1027, + fn1028, + fn1029, + fn1030, + fn1031, + fn1032, + fn1033, + fn1034, + fn1035, + fn1036, + fn1037, + fn1038, + fn1039, + fn1040, + fn1041, + fn1042, + fn1043, + fn1044, + fn1045, + fn1046, + fn1047, + fn1048, + fn1049, + fn1050, + fn1051, + fn1052, + fn1053, + fn1054, + fn1055, + fn1056, + fn1057, + fn1058, + fn1059, + fn1060, + fn1061, + fn1062, + fn1063, + fn1064, + fn1065, + fn1066, + fn1067, + fn1068, + fn1069, + fn1070, + fn1071, + fn1072, + fn1073, + fn1074, + fn1075, + fn1076, + fn1077, + fn1078, + fn1079, + fn1080, + fn1081, + fn1082, + fn1083, + fn1084, + fn1085, + fn1086, + fn1087, + fn1088, + fn1089, + fn1090, + fn1091, + fn1092, + fn1093, + fn1094, + fn1095, + fn1096, + fn1097, + fn1098, + fn1099, + fn1100, + fn1101, + fn1102, + fn1103, + fn1104, + fn1105, + fn1106, + fn1107, + fn1108, + fn1109, + fn1110, + fn1111, + fn1112, + fn1113, + fn1114, + fn1115, + fn1116, + fn1117, + fn1118, + fn1119, + fn1120, + fn1121, + fn1122, + fn1123, + fn1124, + fn1125, + fn1126, + fn1127, + fn1128, + fn1129, + fn1130, + fn1131, + fn1132, + fn1133, + fn1134, + fn1135, + fn1136, + fn1137, + fn1138, + fn1139, + fn1140, + fn1141, + fn1142, + fn1143, + fn1144, + fn1145, + fn1146, + fn1147, + fn1148, + fn1149, + fn1150, + fn1151, + fn1152, + fn1153, + fn1154, + fn1155, + fn1156, + fn1157, + fn1158, + fn1159, + fn1160, + fn1161, + fn1162, + fn1163, + fn1164, + fn1165, + fn1166, + fn1167, + fn1168, + fn1169, + fn1170, + fn1171, + fn1172, + fn1173, + fn1174, + fn1175, + fn1176, + fn1177, + fn1178, + fn1179, + fn1180, + fn1181, + fn1182, + fn1183, + fn1184, + fn1185, + fn1186, + fn1187, + fn1188, + fn1189, + fn1190, + fn1191, + fn1192, + fn1193, + fn1194, + fn1195, + fn1196, + fn1197, + fn1198, + fn1199, + fn1200, + fn1201, + fn1202, + fn1203, + fn1204, + fn1205, + fn1206, + fn1207, + fn1208, + fn1209, + fn1210, + fn1211, + fn1212, + fn1213, + fn1214, + fn1215, + fn1216, + fn1217, + fn1218, + fn1219, + fn1220, + fn1221, + fn1222, + fn1223, + fn1224, + fn1225, + fn1226, + fn1227, + fn1228, + fn1229, + fn1230, + fn1231, + fn1232, + fn1233, + fn1234, + fn1235, + fn1236, + fn1237, + fn1238, + fn1239, + fn1240, + fn1241, + fn1242, + fn1243, + fn1244, + fn1245, + fn1246, + fn1247, + fn1248, + fn1249, + fn1250, + fn1251, + fn1252, + fn1253, + fn1254, + fn1255, + fn1256, + fn1257, + fn1258, + fn1259, + fn1260, + fn1261, + fn1262, + fn1263, + fn1264, + fn1265, + fn1266, + fn1267, + fn1268, + fn1269, + fn1270, + fn1271, + fn1272, + fn1273, + fn1274, + fn1275, + fn1276, + fn1277, + fn1278, + fn1279, + fn1280, + fn1281, + fn1282, + fn1283, + fn1284, + fn1285, + fn1286, + fn1287, + fn1288, + fn1289, + fn1290, + fn1291, + fn1292, + fn1293, + fn1294, + fn1295, + fn1296, + fn1297, + fn1298, + fn1299, + fn1300, + fn1301, + fn1302, + fn1303, + fn1304, + fn1305, + fn1306, + fn1307, + fn1308, + fn1309, + fn1310, + fn1311, + fn1312, + fn1313, + fn1314, + fn1315, + fn1316, + fn1317, + fn1318, + fn1319, + fn1320, + fn1321, + fn1322, + fn1323, + fn1324, + fn1325, + fn1326, + fn1327, + fn1328, + fn1329, + fn1330, + fn1331, + fn1332, + fn1333, + fn1334, + fn1335, + fn1336, + fn1337, + fn1338, + fn1339, + fn1340, + fn1341, + fn1342, + fn1343, + fn1344, + fn1345, + fn1346, + fn1347, + fn1348, + fn1349, + fn1350, + fn1351, + fn1352, + fn1353, + fn1354, + fn1355, + fn1356, + fn1357, + fn1358, + fn1359, + fn1360, + fn1361, + fn1362, + fn1363, + fn1364, + fn1365, + fn1366, + fn1367, + fn1368, + fn1369, + fn1370, + fn1371, + fn1372, + fn1373, + fn1374, + fn1375, + fn1376, + fn1377, + fn1378, + fn1379, + fn1380, + fn1381, + fn1382, + fn1383, + fn1384, + fn1385, + fn1386, + fn1387, + fn1388, + fn1389, + fn1390, + fn1391, + fn1392, + fn1393, + fn1394, + fn1395, + fn1396, + fn1397, + fn1398, + fn1399, + fn1400, + fn1401, + fn1402, + fn1403, + fn1404, + fn1405, + fn1406, + fn1407, + fn1408, + fn1409, + fn1410, + fn1411, + fn1412, + fn1413, + fn1414, + fn1415, + fn1416, + fn1417, + fn1418, + fn1419, + fn1420, + fn1421, + fn1422, + fn1423, + fn1424, + fn1425, + fn1426, + fn1427, + fn1428, + fn1429, + fn1430, + fn1431, + fn1432, + fn1433, + fn1434, + fn1435, + fn1436, + fn1437, + fn1438, + fn1439, + fn1440, + fn1441, + fn1442, + fn1443, + fn1444, + fn1445, + fn1446, + fn1447, + fn1448, + fn1449, + fn1450, + fn1451, + fn1452, + fn1453, + fn1454, + fn1455, + fn1456, + fn1457, + fn1458, + fn1459, + fn1460, + fn1461, + fn1462, + fn1463, + fn1464, + fn1465, + fn1466, + fn1467, + fn1468, + fn1469, + fn1470, + fn1471, + fn1472, + fn1473, + fn1474, + fn1475, + fn1476, + fn1477, + fn1478, + fn1479, + fn1480, + fn1481, + fn1482, + fn1483, + fn1484, + fn1485, + fn1486, + fn1487, + fn1488, + fn1489, + fn1490, + fn1491, + fn1492, + fn1493, + fn1494, + fn1495, + fn1496, + fn1497, + fn1498, + fn1499, + fn1500, + fn1501, + fn1502, + fn1503, + fn1504, + fn1505, + fn1506, + fn1507, + fn1508, + fn1509, + fn1510, + fn1511, + fn1512, + fn1513, + fn1514, + fn1515, + fn1516, + fn1517, + fn1518, + fn1519, + fn1520, + fn1521, + fn1522, + fn1523, + fn1524, + fn1525, + fn1526, + fn1527, + fn1528, + fn1529, + fn1530, + fn1531, + fn1532, + fn1533, + fn1534, + fn1535, + fn1536, + fn1537, + fn1538, + fn1539, + fn1540, + fn1541, + fn1542, + fn1543, + fn1544, + fn1545, + fn1546, + fn1547, + fn1548, + fn1549, + fn1550, + fn1551, + fn1552, + fn1553, + fn1554, + fn1555, + fn1556, + fn1557, + fn1558, + fn1559, + fn1560, + fn1561, + fn1562, + fn1563, + fn1564, + fn1565, + fn1566, + fn1567, + fn1568, + fn1569, + fn1570, + fn1571, + fn1572, + fn1573, + fn1574, + fn1575, + fn1576, + fn1577, + fn1578, + fn1579, + fn1580, + fn1581, + fn1582, + fn1583, + fn1584, + fn1585, + fn1586, + fn1587, + fn1588, + fn1589, + fn1590, + fn1591, + fn1592, + fn1593, + fn1594, + fn1595, + fn1596, + fn1597, + fn1598, + fn1599, + fn1600, + fn1601, + fn1602, + fn1603, + fn1604, + fn1605, + fn1606, + fn1607, + fn1608, + fn1609, + fn1610, + fn1611, + fn1612, + fn1613, + fn1614, + fn1615, + fn1616, + fn1617, + fn1618, + fn1619, + fn1620, + fn1621, + fn1622, + fn1623, + fn1624, + fn1625, + fn1626, + fn1627, + fn1628, + fn1629, + fn1630, + fn1631, + fn1632, + fn1633, + fn1634, + fn1635, + fn1636, + fn1637, + fn1638, + fn1639, + fn1640, + fn1641, + fn1642, + fn1643, + fn1644, + fn1645, + fn1646, + fn1647, + fn1648, + fn1649, + fn1650, + fn1651, + fn1652, + fn1653, + fn1654, + fn1655, + fn1656, + fn1657, + fn1658, + fn1659, + fn1660, + fn1661, + fn1662, + fn1663, + fn1664, + fn1665, + fn1666, + fn1667, + fn1668, + fn1669, + fn1670, + fn1671, + fn1672, + fn1673, + fn1674, + fn1675, + fn1676, + fn1677, + fn1678, + fn1679, + fn1680, + fn1681, + fn1682, + fn1683, + fn1684, + fn1685, + fn1686, + fn1687, + fn1688, + fn1689, + fn1690, + fn1691, + fn1692, + fn1693, + fn1694, + fn1695, + fn1696, + fn1697, + fn1698, + fn1699, + fn1700, + fn1701, + fn1702, + fn1703, + fn1704, + fn1705, + fn1706, + fn1707, + fn1708, + fn1709, + fn1710, + fn1711, + fn1712, + fn1713, + fn1714, + fn1715, + fn1716, + fn1717, + fn1718, + fn1719, + fn1720, + fn1721, + fn1722, + fn1723, + fn1724, + fn1725, + fn1726, + fn1727, + fn1728, + fn1729, + fn1730, + fn1731, + fn1732, + fn1733, + fn1734, + fn1735, + fn1736, + fn1737, + fn1738, + fn1739, + fn1740, + fn1741, + fn1742, + fn1743, + fn1744, + fn1745, + fn1746, + fn1747, + fn1748, + fn1749, + fn1750, + fn1751, + fn1752, + fn1753, + fn1754, + fn1755, + fn1756, + fn1757, + fn1758, + fn1759, + fn1760, + fn1761, + fn1762, + fn1763, + fn1764, + fn1765, + fn1766, + fn1767, + fn1768, + fn1769, + fn1770, + fn1771, + fn1772, + fn1773, + fn1774, + fn1775, + fn1776, + fn1777, + fn1778, + fn1779, + fn1780, + fn1781, + fn1782, + fn1783, + fn1784, + fn1785, + fn1786, + fn1787, + fn1788, + fn1789, + fn1790, + fn1791, + fn1792, + fn1793, + fn1794, + fn1795, + fn1796, + fn1797, + fn1798, + fn1799, + fn1800, + fn1801, + fn1802, + fn1803, + fn1804, + fn1805, + fn1806, + fn1807, + fn1808, + fn1809, + fn1810, + fn1811, + fn1812, + fn1813, + fn1814, + fn1815, + fn1816, + fn1817, + fn1818, + fn1819, + fn1820, + fn1821, + fn1822, + fn1823, + fn1824, + fn1825, + fn1826, + fn1827, + fn1828, + fn1829, + fn1830, + fn1831, + fn1832, + fn1833, + fn1834, + fn1835, + fn1836, + fn1837, + fn1838, + fn1839, + fn1840, + fn1841, + fn1842, + fn1843, + fn1844, + fn1845, + fn1846, + fn1847, + fn1848, + fn1849, + fn1850, + fn1851, + fn1852, + fn1853, + fn1854, + fn1855, + fn1856, + fn1857, + fn1858, + fn1859, + fn1860, + fn1861, + fn1862, + fn1863, + fn1864, + fn1865, + fn1866, + fn1867, + fn1868, + fn1869, + fn1870, + fn1871, + fn1872, + fn1873, + fn1874, + fn1875, + fn1876, + fn1877, + fn1878, + fn1879, + fn1880, + fn1881, + fn1882, + fn1883, + fn1884, + fn1885, + fn1886, + fn1887, + fn1888, + fn1889, + fn1890, + fn1891, + fn1892, + fn1893, + fn1894, + fn1895, + fn1896, + fn1897, + fn1898, + fn1899, + fn1900, + fn1901, + fn1902, + fn1903, + fn1904, + fn1905, + fn1906, + fn1907, + fn1908, + fn1909, + fn1910, + fn1911, + fn1912, + fn1913, + fn1914, + fn1915, + fn1916, + fn1917, + fn1918, + fn1919, + fn1920, + fn1921, + fn1922, + fn1923, + fn1924, + fn1925, + fn1926, + fn1927, + fn1928, + fn1929, + fn1930, + fn1931, + fn1932, + fn1933, + fn1934, + fn1935, + fn1936, + fn1937, + fn1938, + fn1939, + fn1940, + fn1941, + fn1942, + fn1943, + fn1944, + fn1945, + fn1946, + fn1947, + fn1948, + fn1949, + fn1950, + fn1951, + fn1952, + fn1953, + fn1954, + fn1955, + fn1956, + fn1957, + fn1958, + fn1959, + fn1960, + fn1961, + fn1962, + fn1963, + fn1964, + fn1965, + fn1966, + fn1967, + fn1968, + fn1969, + fn1970, + fn1971, + fn1972, + fn1973, + fn1974, + fn1975, + fn1976, + fn1977, + fn1978, + fn1979, + fn1980, + fn1981, + fn1982, + fn1983, + fn1984, + fn1985, + fn1986, + fn1987, + fn1988, + fn1989, + fn1990, + fn1991, + fn1992, + fn1993, + fn1994, + fn1995, + fn1996, + fn1997, + fn1998, + fn1999, + fn2000, + fn2001, + fn2002, + fn2003, + fn2004, + fn2005, + fn2006, + fn2007, + fn2008, + fn2009, + fn2010, + fn2011, + fn2012, + fn2013, +}; +pub fn main() void { + @panic("slice_runtime_panic_variants"); +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/slice sentinel mismatch - floats.zig b/test/cases/safety/slice_sentinel_mismatch-floats.zig similarity index 51% rename from test/cases/safety/slice sentinel mismatch - floats.zig rename to test/cases/safety/slice_sentinel_mismatch-floats.zig index 19b9b86c3ba8..808846f5a439 100644 --- a/test/cases/safety/slice sentinel mismatch - floats.zig +++ b/test/cases/safety/slice_sentinel_mismatch-floats.zig @@ -1,20 +1,17 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected 1.2e0, found 4e0")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_sentinel) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_sentinel', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var buf: [4]f32 = .{ 1, 2, 3, 4 }; const slice = buf[0..3 :1.2]; _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/slice sentinel mismatch - optional pointers.zig b/test/cases/safety/slice_sentinel_mismatch-optional_pointers.zig similarity index 55% rename from test/cases/safety/slice sentinel mismatch - optional pointers.zig rename to test/cases/safety/slice_sentinel_mismatch-optional_pointers.zig index a3b4a98575e6..ee2eb6c18310 100644 --- a/test/cases/safety/slice sentinel mismatch - optional pointers.zig +++ b/test/cases/safety/slice_sentinel_mismatch-optional_pointers.zig @@ -1,20 +1,17 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected null, found i32@10")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_sentinel) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_sentinel', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var buf: [4]?*i32 = .{ @ptrFromInt(4), @ptrFromInt(8), @ptrFromInt(12), @ptrFromInt(16) }; const slice = buf[0..3 :null]; _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/slice slice sentinel mismatch.zig b/test/cases/safety/slice_slice_sentinel_mismatch.zig similarity index 52% rename from test/cases/safety/slice slice sentinel mismatch.zig rename to test/cases/safety/slice_slice_sentinel_mismatch.zig index 635706b2c58a..272d57a77b49 100644 --- a/test/cases/safety/slice slice sentinel mismatch.zig +++ b/test/cases/safety/slice_slice_sentinel_mismatch.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "sentinel mismatch: expected 0, found 4")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mismatched_null_sentinel) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mismatched_null_sentinel', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var buf: [4]u8 = .{ 1, 2, 3, 4 }; const slice = buf[0..]; diff --git a/test/cases/safety/slice start index greater than end index.zig b/test/cases/safety/slice_start_index_greater_than_end_index.zig similarity index 54% rename from test/cases/safety/slice start index greater than end index.zig rename to test/cases/safety/slice_start_index_greater_than_end_index.zig index 83d489ab5699..d8024e2e2148 100644 --- a/test/cases/safety/slice start index greater than end index.zig +++ b/test/cases/safety/slice_start_index_greater_than_end_index.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "start index 10 is larger than end index 1")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_out_of_order_extra) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_out_of_order_extra', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var a: usize = 1; var b: usize = 10; @@ -18,7 +16,6 @@ pub fn main() !void { _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/slice_with_sentinel_out_of_bounds-runtime_len.zig b/test/cases/safety/slice_with_sentinel_out_of_bounds-runtime_len.zig new file mode 100644 index 000000000000..5202e958d87c --- /dev/null +++ b/test/cases/safety/slice_with_sentinel_out_of_bounds-runtime_len.zig @@ -0,0 +1,20 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_out_of_bounds) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_out_of_bounds', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + var buf = [4:0]u8{ 'a', 'b', 'c', 0 }; + const input: []const u8 = &buf; + const len: usize = 4; + _ = &len; + const slice = input[0..len :0]; + _ = slice; + return error.TestFailed; +} +// run +// backend=llvm +// target=native diff --git a/test/cases/safety/slice with sentinel out of bounds.zig b/test/cases/safety/slice_with_sentinel_out_of_bounds.zig similarity index 53% rename from test/cases/safety/slice with sentinel out of bounds.zig rename to test/cases/safety/slice_with_sentinel_out_of_bounds.zig index 1683dc9d3f32..223d34ce02b5 100644 --- a/test/cases/safety/slice with sentinel out of bounds.zig +++ b/test/cases/safety/slice_with_sentinel_out_of_bounds.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "index out of bounds: index 5, len 4")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_out_of_bounds) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_out_of_bounds', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var buf = [4]u8{ 'a', 'b', 'c', 0 }; const input: []u8 = &buf; @@ -15,7 +13,6 @@ pub fn main() !void { _ = slice; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/slicing null C pointer - runtime len.zig b/test/cases/safety/slicing_null_C_pointer-runtime_len.zig similarity index 53% rename from test/cases/safety/slicing null C pointer - runtime len.zig rename to test/cases/safety/slicing_null_C_pointer-runtime_len.zig index dd73a5011205..1918a42e03b6 100644 --- a/test/cases/safety/slicing null C pointer - runtime len.zig +++ b/test/cases/safety/slicing_null_C_pointer-runtime_len.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_null_value) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_null_value', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var ptr: [*c]const u32 = null; var len: usize = 3; diff --git a/test/cases/safety/slicing null C pointer.zig b/test/cases/safety/slicing_null_C_pointer.zig similarity index 51% rename from test/cases/safety/slicing null C pointer.zig rename to test/cases/safety/slicing_null_C_pointer.zig index 862f2dcfdba6..3662f116eb4f 100644 --- a/test/cases/safety/slicing null C pointer.zig +++ b/test/cases/safety/slicing_null_C_pointer.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to use null value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .accessed_null_value) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.accessed_null_value', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var ptr: [*c]const u32 = null; _ = &ptr; diff --git a/test/cases/safety/switch else on corrupt enum value - one prong.zig b/test/cases/safety/switch_else_on_corrupt_enum_value-one_prong.zig similarity index 56% rename from test/cases/safety/switch else on corrupt enum value - one prong.zig rename to test/cases/safety/switch_else_on_corrupt_enum_value-one_prong.zig index c11227c3bee8..7a7a66a5283f 100644 --- a/test/cases/safety/switch else on corrupt enum value - one prong.zig +++ b/test/cases/safety/switch_else_on_corrupt_enum_value-one_prong.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const E = enum(u32) { one = 1, two = 2, diff --git a/test/cases/safety/switch else on corrupt enum value - union.zig b/test/cases/safety/switch_else_on_corrupt_enum_value-union.zig similarity index 61% rename from test/cases/safety/switch else on corrupt enum value - union.zig rename to test/cases/safety/switch_else_on_corrupt_enum_value-union.zig index a63c78597e66..405f210caa78 100644 --- a/test/cases/safety/switch else on corrupt enum value - union.zig +++ b/test/cases/safety/switch_else_on_corrupt_enum_value-union.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const E = enum(u16) { one = 1, two = 2, diff --git a/test/cases/safety/switch else on corrupt enum value.zig b/test/cases/safety/switch_else_on_corrupt_enum_value.zig similarity index 54% rename from test/cases/safety/switch else on corrupt enum value.zig rename to test/cases/safety/switch_else_on_corrupt_enum_value.zig index 7e050838c086..dda580015f73 100644 --- a/test/cases/safety/switch else on corrupt enum value.zig +++ b/test/cases/safety/switch_else_on_corrupt_enum_value.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); const E = enum(u32) { one = 1, two = 2, diff --git a/test/cases/safety/switch on corrupted enum value.zig b/test/cases/safety/switch_on_corrupted_enum_value.zig similarity index 59% rename from test/cases/safety/switch on corrupted enum value.zig rename to test/cases/safety/switch_on_corrupted_enum_value.zig index f89076191172..f14499887cf3 100644 --- a/test/cases/safety/switch on corrupted enum value.zig +++ b/test/cases/safety/switch_on_corrupted_enum_value.zig @@ -1,18 +1,15 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .corrupt_switch) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.corrupt_switch', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); const E = enum(u32) { X = 1, Y = 2, }; - pub fn main() !void { var e: E = undefined; @memset(@as([*]u8, @ptrCast(&e))[0..@sizeOf(E)], 0x55); @@ -21,7 +18,6 @@ pub fn main() !void { } return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/switch on corrupted union value.zig b/test/cases/safety/switch_on_corrupted_union_value.zig similarity index 60% rename from test/cases/safety/switch on corrupted union value.zig rename to test/cases/safety/switch_on_corrupted_union_value.zig index fc93c9d6e7f0..74061d2c8cf9 100644 --- a/test/cases/safety/switch on corrupted union value.zig +++ b/test/cases/safety/switch_on_corrupted_union_value.zig @@ -1,18 +1,15 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "switch on corrupt value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .corrupt_switch) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.corrupt_switch', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); const U = union(enum(u32)) { X: u8, Y: i8, }; - pub fn main() !void { var u: U = undefined; @memset(@as([*]u8, @ptrCast(&u))[0..@sizeOf(U)], 0x55); @@ -21,7 +18,6 @@ pub fn main() !void { } return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/@tagName on corrupted enum value.zig b/test/cases/safety/tagName_on_corrupted_enum_value.zig similarity index 56% rename from test/cases/safety/@tagName on corrupted enum value.zig rename to test/cases/safety/tagName_on_corrupted_enum_value.zig index e23cd1fcf692..926b0499aeb5 100644 --- a/test/cases/safety/@tagName on corrupted enum value.zig +++ b/test/cases/safety/tagName_on_corrupted_enum_value.zig @@ -1,18 +1,15 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); const E = enum(u32) { X = 1, Y = 2, }; - pub fn main() !void { var e: E = undefined; @memset(@as([*]u8, @ptrCast(&e))[0..@sizeOf(E)], 0x55); @@ -20,7 +17,6 @@ pub fn main() !void { _ = n; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/@tagName on corrupted union value.zig b/test/cases/safety/tagName_on_corrupted_union_value.zig similarity index 60% rename from test/cases/safety/@tagName on corrupted union value.zig rename to test/cases/safety/tagName_on_corrupted_union_value.zig index f742834d1520..b0f209f6b83d 100644 --- a/test/cases/safety/@tagName on corrupted union value.zig +++ b/test/cases/safety/tagName_on_corrupted_union_value.zig @@ -1,18 +1,15 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid enum value")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_enum_from_invalid) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_enum_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); const U = union(enum(u32)) { X: u8, Y: i8, }; - pub fn main() !void { var u: U = undefined; @memset(@as([*]u8, @ptrCast(&u))[0..@sizeOf(U)], 0x55); @@ -21,7 +18,6 @@ pub fn main() !void { _ = n; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/truncating vector cast.zig b/test/cases/safety/truncating_vector_cast.zig similarity index 53% rename from test/cases/safety/truncating vector cast.zig rename to test/cases/safety/truncating_vector_cast.zig index ae76d4dec125..0514b1276637 100644 --- a/test/cases/safety/truncating vector cast.zig +++ b/test/cases/safety/truncating_vector_cast.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var x: @Vector(4, u32) = @splat(0xdeadbeef); _ = &x; @@ -15,7 +13,6 @@ pub fn main() !void { _ = y; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/unreachable.zig b/test/cases/safety/unreachable.zig index 492f7958b18b..7b1cdd9d8f8b 100644 --- a/test/cases/safety/unreachable.zig +++ b/test/cases/safety/unreachable.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "reached unreachable code")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .reached_unreachable) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.reached_unreachable', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { unreachable; } diff --git a/test/cases/safety/unsigned-signed vector cast.zig b/test/cases/safety/unsigned-signed_vector_cast.zig similarity index 53% rename from test/cases/safety/unsigned-signed vector cast.zig rename to test/cases/safety/unsigned-signed_vector_cast.zig index 32676f7c1cb6..f9e28be76da0 100644 --- a/test/cases/safety/unsigned-signed vector cast.zig +++ b/test/cases/safety/unsigned-signed_vector_cast.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { var x: @Vector(4, u32) = @splat(0x80000000); _ = &x; @@ -15,7 +13,6 @@ pub fn main() !void { _ = y; return error.TestFailed; } - // run // backend=llvm // target=native diff --git a/test/cases/safety/unsigned shift left overflow.zig b/test/cases/safety/unsigned_shift_left_overflow.zig similarity index 56% rename from test/cases/safety/unsigned shift left overflow.zig rename to test/cases/safety/unsigned_shift_left_overflow.zig index d38d8f6ecf06..9cb2ba4b2b4c 100644 --- a/test/cases/safety/unsigned shift left overflow.zig +++ b/test/cases/safety/unsigned_shift_left_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "left shift overflowed bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shl_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.shl_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shl(0b0010111111111111, 3); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/unsigned shift right overflow.zig b/test/cases/safety/unsigned_shift_right_overflow.zig similarity index 56% rename from test/cases/safety/unsigned shift right overflow.zig rename to test/cases/safety/unsigned_shift_right_overflow.zig index 121797a17d4c..049953f2c20f 100644 --- a/test/cases/safety/unsigned shift right overflow.zig +++ b/test/cases/safety/unsigned_shift_right_overflow.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "right shift overflowed bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .shr_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.shr_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shr(0b0010111111111111, 3); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig b/test/cases/safety/unsigned_truncated_to_equal_bit_signed.zig similarity index 51% rename from test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig rename to test/cases/safety/unsigned_truncated_to_equal_bit_signed.zig index 9bd4c4200702..826fa732aeb2 100644 --- a/test/cases/safety/unsigned integer not fitting in cast to signed integer - same bit count.zig +++ b/test/cases/safety/unsigned_truncated_to_equal_bit_signed.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var value: u8 = 245; _ = &value; diff --git a/test/cases/safety/unwrap error.zig b/test/cases/safety/unwrap_error.zig similarity index 50% rename from test/cases/safety/unwrap error.zig rename to test/cases/safety/unwrap_error.zig index e2d7ea725b8b..dfb2b45dd9b0 100644 --- a/test/cases/safety/unwrap error.zig +++ b/test/cases/safety/unwrap_error.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .unwrapped_error) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.unwrapped_error', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { bar() catch unreachable; return error.TestFailed; diff --git a/test/cases/safety/unwrap error switch.zig b/test/cases/safety/unwrap_error_switch.zig similarity index 55% rename from test/cases/safety/unwrap error switch.zig rename to test/cases/safety/unwrap_error_switch.zig index 0723a9fb246a..8c1d6a0e58c5 100644 --- a/test/cases/safety/unwrap error switch.zig +++ b/test/cases/safety/unwrap_error_switch.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "attempt to unwrap error: Whatever")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .unwrapped_error) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.unwrapped_error', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { bar() catch |err| switch (err) { error.Whatever => unreachable, diff --git a/test/cases/safety/value does not fit in shortening cast - u0.zig b/test/cases/safety/value_does_not_fit_in_shortening_cast-u0.zig similarity index 54% rename from test/cases/safety/value does not fit in shortening cast - u0.zig rename to test/cases/safety/value_does_not_fit_in_shortening_cast-u0.zig index ec111a2caedd..be105a0d816a 100644 --- a/test/cases/safety/value does not fit in shortening cast - u0.zig +++ b/test/cases/safety/value_does_not_fit_in_shortening_cast-u0.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shorten_cast(1); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/value does not fit in shortening cast.zig b/test/cases/safety/value_does_not_fit_in_shortening_cast.zig similarity index 54% rename from test/cases/safety/value does not fit in shortening cast.zig rename to test/cases/safety/value_does_not_fit_in_shortening_cast.zig index a5ea41659e86..4f638afea146 100644 --- a/test/cases/safety/value does not fit in shortening cast.zig +++ b/test/cases/safety/value_does_not_fit_in_shortening_cast.zig @@ -1,13 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer cast truncated bits")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_truncated_data) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_truncated_data', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } - +const std = @import("std"); pub fn main() !void { const x = shorten_cast(200); if (x == 0) return error.Whatever; diff --git a/test/cases/safety/vector integer addition overflow.zig b/test/cases/safety/vector_integer_addition_overflow.zig similarity index 62% rename from test/cases/safety/vector integer addition overflow.zig rename to test/cases/safety/vector_integer_addition_overflow.zig index 21c26eeb4e47..e239bacabcd7 100644 --- a/test/cases/safety/vector integer addition overflow.zig +++ b/test/cases/safety/vector_integer_addition_overflow.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .add_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.add_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const a: @Vector(4, i32) = [_]i32{ 1, 2, 2147483643, 4 }; const b: @Vector(4, i32) = [_]i32{ 5, 6, 7, 8 }; diff --git a/test/cases/safety/vector integer multiplication overflow.zig b/test/cases/safety/vector_integer_multiplication_overflow.zig similarity index 61% rename from test/cases/safety/vector integer multiplication overflow.zig rename to test/cases/safety/vector_integer_multiplication_overflow.zig index 8678eccec6fe..4c239a6de59d 100644 --- a/test/cases/safety/vector integer multiplication overflow.zig +++ b/test/cases/safety/vector_integer_multiplication_overflow.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .mul_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.mul_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const a: @Vector(4, u8) = [_]u8{ 1, 2, 200, 4 }; const b: @Vector(4, u8) = [_]u8{ 5, 6, 2, 8 }; diff --git a/test/cases/safety/vector integer negation overflow.zig b/test/cases/safety/vector_integer_negation_overflow.zig similarity index 58% rename from test/cases/safety/vector integer negation overflow.zig rename to test/cases/safety/vector_integer_negation_overflow.zig index 5f8becad177c..36a5dea243f3 100644 --- a/test/cases/safety/vector integer negation overflow.zig +++ b/test/cases/safety/vector_integer_negation_overflow.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .sub_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.sub_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { var a: @Vector(4, i16) = [_]i16{ 1, -32768, 200, 4 }; _ = &a; diff --git a/test/cases/safety/vector integer subtraction overflow.zig b/test/cases/safety/vector_integer_subtraction_overflow.zig similarity index 62% rename from test/cases/safety/vector integer subtraction overflow.zig rename to test/cases/safety/vector_integer_subtraction_overflow.zig index 82c034212104..0b37584f6512 100644 --- a/test/cases/safety/vector integer subtraction overflow.zig +++ b/test/cases/safety/vector_integer_subtraction_overflow.zig @@ -1,12 +1,11 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "integer overflow")) { +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .sub_overflowed) { std.process.exit(0); } + std.debug.print(@src().file ++ ": Expected panic cause: '.sub_overflowed', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); std.process.exit(1); } +const std = @import("std"); pub fn main() !void { const a: @Vector(4, u32) = [_]u32{ 1, 2, 8, 4 }; const b: @Vector(4, u32) = [_]u32{ 5, 6, 7, 8 }; diff --git a/test/cases/safety/zero casted to error.zig b/test/cases/safety/zero casted to error.zig deleted file mode 100644 index 78340db3163c..000000000000 --- a/test/cases/safety/zero casted to error.zig +++ /dev/null @@ -1,19 +0,0 @@ -const std = @import("std"); - -pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { - _ = stack_trace; - if (std.mem.eql(u8, message, "invalid error code")) { - std.process.exit(0); - } - std.process.exit(1); -} -pub fn main() !void { - bar(0) catch {}; - return error.TestFailed; -} -fn bar(x: u16) anyerror { - return @errorFromInt(x); -} -// run -// backend=llvm -// target=native diff --git a/test/cases/safety/zero_casted_to_error.zig b/test/cases/safety/zero_casted_to_error.zig new file mode 100644 index 000000000000..ce6d8f9d69b0 --- /dev/null +++ b/test/cases/safety/zero_casted_to_error.zig @@ -0,0 +1,18 @@ +pub fn panic2(comptime cause: std.builtin.PanicCause, _: anytype) noreturn { + if (cause == .cast_to_error_from_invalid) { + std.process.exit(0); + } + std.debug.print(@src().file ++ ": Expected panic cause: '.cast_to_error_from_invalid', found panic cause: '." ++ @tagName(cause) ++ "'\n", .{}); + std.process.exit(1); +} +const std = @import("std"); +pub fn main() !void { + bar(0) catch {}; + return error.TestFailed; +} +fn bar(x: u16) anyerror { + return @errorFromInt(x); +} +// run +// backend=llvm +// target=native diff --git a/test/tests.zig b/test/tests.zig index c0ef4a536a35..0aadf1e110bf 100644 --- a/test/tests.zig +++ b/test/tests.zig @@ -794,6 +794,13 @@ pub fn addCliTests(b: *std.Build) *Step { \\ _ = error_return_trace; \\ zig_panic(); \\} + \\pub fn panic2( + \\ comptime panic_cause: @import("std").builtin.PanicCause, + \\ _: @import("std").builtin.PanicData(panic_cause), + \\) noreturn { + \\ zig_panic(); + \\} + \\ ); // This is intended to be the exact CLI usage used by godbolt.org.