mirror of
https://github.com/roc-lang/roc.git
synced 2025-08-03 03:42:17 +00:00
Merge branch 'list-unsafe-append' into can-builtins-cleanup
This commit is contained in:
Folkert
commit
0f86886ab7
24 changed files with 249 additions and 470 deletions
|
|
@ -1,134 +0,0 @@
|
|||
const std = @import("std");
|
||||
const utils = @import("utils.zig");
|
||||
const CSlice = utils.CSlice;
|
||||
const always_inline = std.builtin.CallOptions.Modifier.always_inline;
|
||||
|
||||
const Failure = struct {
|
||||
start_line: u32,
|
||||
end_line: u32,
|
||||
start_col: u16,
|
||||
end_col: u16,
|
||||
};
|
||||
|
||||
// BEGIN FAILURES GLOBALS ///////////////////
|
||||
var failures_mutex = std.Thread.Mutex{};
|
||||
var failures: [*]Failure = undefined;
|
||||
var failure_length: usize = 0;
|
||||
var failure_capacity: usize = 0;
|
||||
// END FAILURES GLOBALS /////////////////////
|
||||
|
||||
pub fn expectFailed(
|
||||
start_line: u32,
|
||||
end_line: u32,
|
||||
start_col: u16,
|
||||
end_col: u16,
|
||||
) void {
|
||||
const new_failure = Failure{ .start_line = start_line, .end_line = end_line, .start_col = start_col, .end_col = end_col };
|
||||
|
||||
// Lock the failures mutex before reading from any of the failures globals,
|
||||
// and then release the lock once we're done modifying things.
|
||||
failures_mutex.lock();
|
||||
defer failures_mutex.unlock();
|
||||
|
||||
// If we don't have enough capacity to add a failure, allocate a new failures pointer.
|
||||
if (failure_length >= failure_capacity) {
|
||||
if (failure_capacity > 0) {
|
||||
// We already had previous failures allocated, so try to realloc in order
|
||||
// to grow the size in-place without having to memcpy bytes over.
|
||||
const old_pointer = failures;
|
||||
const old_bytes = failure_capacity * @sizeOf(Failure);
|
||||
|
||||
failure_capacity *= 2;
|
||||
|
||||
const new_bytes = failure_capacity * @sizeOf(Failure);
|
||||
const failures_u8 = @ptrCast([*]u8, @alignCast(@alignOf(Failure), failures));
|
||||
const raw_pointer = utils.realloc(failures_u8, new_bytes, old_bytes, @alignOf(Failure));
|
||||
|
||||
failures = @ptrCast([*]Failure, @alignCast(@alignOf(Failure), raw_pointer));
|
||||
|
||||
// If realloc wasn't able to expand in-place (that is, it returned a different pointer),
|
||||
// then copy the data into the new pointer and dealloc the old one.
|
||||
if (failures != old_pointer) {
|
||||
const old_pointer_u8 = @ptrCast([*]u8, old_pointer);
|
||||
utils.memcpy(@ptrCast([*]u8, failures), old_pointer_u8, old_bytes);
|
||||
utils.dealloc(old_pointer_u8, @alignOf(Failure));
|
||||
}
|
||||
} else {
|
||||
// We've never had any failures before, so allocate the failures for the first time.
|
||||
failure_capacity = 10;
|
||||
|
||||
const raw_pointer = utils.alloc(failure_capacity * @sizeOf(Failure), @alignOf(Failure));
|
||||
|
||||
failures = @ptrCast([*]Failure, @alignCast(@alignOf(Failure), raw_pointer));
|
||||
}
|
||||
}
|
||||
|
||||
failures[failure_length] = new_failure;
|
||||
failure_length += 1;
|
||||
}
|
||||
|
||||
pub fn expectFailedC(
|
||||
start_line: u32,
|
||||
end_line: u32,
|
||||
start_col: u16,
|
||||
end_col: u16,
|
||||
) callconv(.C) void {
|
||||
return @call(.{ .modifier = always_inline }, expectFailed, .{ start_line, end_line, start_col, end_col });
|
||||
}
|
||||
|
||||
pub fn getExpectFailures() []Failure {
|
||||
failures_mutex.lock();
|
||||
defer failures_mutex.unlock();
|
||||
|
||||
if (failure_length > 0) {
|
||||
// defensively clone failures, in case someone modifies the originals after the mutex has been released.
|
||||
const num_bytes = failure_length * @sizeOf(Failure);
|
||||
// TODO handle the possibility of alloc failing
|
||||
const raw_clones = utils.alloc(num_bytes, @alignOf(Failure)) orelse unreachable;
|
||||
|
||||
utils.memcpy(raw_clones, @ptrCast([*]u8, failures), num_bytes);
|
||||
|
||||
const clones = @ptrCast([*]Failure, @alignCast(@alignOf(Failure), raw_clones));
|
||||
|
||||
return clones[0..failure_length];
|
||||
} else {
|
||||
return failures[0..0];
|
||||
}
|
||||
}
|
||||
|
||||
pub fn getExpectFailuresC() callconv(.C) CSlice {
|
||||
var bytes = @ptrCast(*anyopaque, failures);
|
||||
|
||||
return .{ .pointer = bytes, .len = failure_length };
|
||||
}
|
||||
|
||||
pub fn deinitFailures() void {
|
||||
failures_mutex.lock();
|
||||
defer failures_mutex.unlock();
|
||||
|
||||
utils.dealloc(@ptrCast([*]u8, failures), @alignOf(Failure));
|
||||
failure_length = 0;
|
||||
}
|
||||
|
||||
pub fn deinitFailuresC() callconv(.C) void {
|
||||
return @call(.{ .modifier = always_inline }, deinitFailures, .{});
|
||||
}
|
||||
|
||||
test "expectFailure does something" {
|
||||
defer deinitFailures();
|
||||
|
||||
var fails = getExpectFailures();
|
||||
try std.testing.expectEqual(fails.len, 0);
|
||||
|
||||
expectFailed(1, 2, 3, 4);
|
||||
|
||||
fails = getExpectFailures();
|
||||
try std.testing.expectEqual(fails.len, 1);
|
||||
utils.dealloc(@ptrCast([*]u8, fails.ptr), @alignOf([*]Failure));
|
||||
|
||||
const what_it_should_look_like = Failure{ .start_line = 1, .end_line = 2, .start_col = 3, .end_col = 4 };
|
||||
|
||||
fails = getExpectFailures();
|
||||
try std.testing.expectEqual(fails[0], what_it_should_look_like);
|
||||
utils.dealloc(@ptrCast([*]u8, fails.ptr), @alignOf([*]Failure));
|
||||
}
|
||||
|
|
@ -2,7 +2,6 @@ const std = @import("std");
|
|||
const builtin = @import("builtin");
|
||||
const math = std.math;
|
||||
const utils = @import("utils.zig");
|
||||
const expect = @import("expect.zig");
|
||||
|
||||
const ROC_BUILTINS = "roc_builtins";
|
||||
const NUM = "num";
|
||||
|
|
@ -185,9 +184,6 @@ comptime {
|
|||
exportUtilsFn(utils.decrefC, "decref");
|
||||
exportUtilsFn(utils.decrefCheckNullC, "decref_check_null");
|
||||
exportUtilsFn(utils.allocateWithRefcountC, "allocate_with_refcount");
|
||||
exportExpectFn(expect.expectFailedC, "expect_failed");
|
||||
exportExpectFn(expect.getExpectFailuresC, "get_expect_failures");
|
||||
exportExpectFn(expect.deinitFailuresC, "deinit_failures");
|
||||
|
||||
@export(utils.panic, .{ .name = "roc_builtins.utils." ++ "panic", .linkage = .Weak });
|
||||
|
||||
|
|
@ -241,10 +237,6 @@ fn exportUtilsFn(comptime func: anytype, comptime func_name: []const u8) void {
|
|||
exportBuiltinFn(func, "utils." ++ func_name);
|
||||
}
|
||||
|
||||
fn exportExpectFn(comptime func: anytype, comptime func_name: []const u8) void {
|
||||
exportBuiltinFn(func, "expect." ++ func_name);
|
||||
}
|
||||
|
||||
// Custom panic function, as builtin Zig version errors during LLVM verification
|
||||
pub fn panic(message: []const u8, stacktrace: ?*std.builtin.StackTrace) noreturn {
|
||||
if (builtin.is_test) {
|
||||
|
|
|
|||
|
|
@ -393,9 +393,6 @@ pub const UTILS_ALLOCATE_WITH_REFCOUNT: &str = "roc_builtins.utils.allocate_with
|
|||
pub const UTILS_INCREF: &str = "roc_builtins.utils.incref";
|
||||
pub const UTILS_DECREF: &str = "roc_builtins.utils.decref";
|
||||
pub const UTILS_DECREF_CHECK_NULL: &str = "roc_builtins.utils.decref_check_null";
|
||||
pub const UTILS_EXPECT_FAILED: &str = "roc_builtins.expect.expect_failed";
|
||||
pub const UTILS_GET_EXPECT_FAILURES: &str = "roc_builtins.expect.get_expect_failures";
|
||||
pub const UTILS_DEINIT_FAILURES: &str = "roc_builtins.expect.deinit_failures";
|
||||
|
||||
pub const UTILS_LONGJMP: &str = "longjmp";
|
||||
pub const UTILS_SETJMP: &str = "setjmp";
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ use inkwell::types::{
|
|||
};
|
||||
use inkwell::values::BasicValueEnum::{self, *};
|
||||
use inkwell::values::{
|
||||
BasicMetadataValueEnum, BasicValue, CallSiteValue, CallableValue, FloatValue, FunctionValue,
|
||||
BasicMetadataValueEnum, BasicValue, CallSiteValue, FloatValue, FunctionValue,
|
||||
InstructionOpcode, InstructionValue, IntValue, PhiValue, PointerValue, StructValue,
|
||||
};
|
||||
use inkwell::OptimizationLevel;
|
||||
|
|
@ -65,7 +65,7 @@ use roc_mono::layout::{
|
|||
};
|
||||
use roc_std::RocDec;
|
||||
use roc_target::{PtrWidth, TargetInfo};
|
||||
use std::convert::{TryFrom, TryInto};
|
||||
use std::convert::TryInto;
|
||||
use std::path::Path;
|
||||
use target_lexicon::{Architecture, OperatingSystem, Triple};
|
||||
|
||||
|
|
@ -2779,30 +2779,8 @@ pub fn build_exp_stmt<'a, 'ctx, 'env>(
|
|||
|
||||
match env.target_info.ptr_width() {
|
||||
roc_target::PtrWidth::Bytes8 => {
|
||||
let func = env
|
||||
.module
|
||||
.get_function(bitcode::UTILS_EXPECT_FAILED)
|
||||
.unwrap();
|
||||
// TODO get the actual line info instead of
|
||||
// hardcoding as zero!
|
||||
let callable = CallableValue::try_from(func).unwrap();
|
||||
let start_line = context.i32_type().const_int(0, false);
|
||||
let end_line = context.i32_type().const_int(0, false);
|
||||
let start_col = context.i16_type().const_int(0, false);
|
||||
let end_col = context.i16_type().const_int(0, false);
|
||||
|
||||
bd.build_call(
|
||||
callable,
|
||||
&[
|
||||
start_line.into(),
|
||||
end_line.into(),
|
||||
start_col.into(),
|
||||
end_col.into(),
|
||||
],
|
||||
"call_expect_failed",
|
||||
);
|
||||
|
||||
bd.build_unconditional_branch(then_block);
|
||||
// temporary native implementation
|
||||
throw_exception(env, "An expectation failed!");
|
||||
}
|
||||
roc_target::PtrWidth::Bytes4 => {
|
||||
// temporary WASM implementation
|
||||
|
|
|
|||
|
|
@ -47,43 +47,6 @@ pub fn add_default_roc_externs(env: &Env<'_, '_, '_>) {
|
|||
}
|
||||
}
|
||||
|
||||
// roc_memcpy
|
||||
{
|
||||
// The type of this function (but not the implementation) should have
|
||||
// already been defined by the builtins, which rely on it.
|
||||
let fn_val = module.get_function("roc_memcpy").unwrap();
|
||||
let mut params = fn_val.get_param_iter();
|
||||
let dest_arg = params.next().unwrap();
|
||||
let dest_alignment = 1;
|
||||
let src_arg = params.next().unwrap();
|
||||
let src_alignment = 1;
|
||||
let bytes_arg = params.next().unwrap();
|
||||
|
||||
debug_assert!(params.next().is_none());
|
||||
|
||||
// Add a basic block for the entry point
|
||||
let entry = ctx.append_basic_block(fn_val, "entry");
|
||||
|
||||
builder.position_at_end(entry);
|
||||
|
||||
// Call libc memcpy()
|
||||
let _retval = builder
|
||||
.build_memcpy(
|
||||
dest_arg.into_pointer_value(),
|
||||
dest_alignment,
|
||||
src_arg.into_pointer_value(),
|
||||
src_alignment,
|
||||
bytes_arg.into_int_value(),
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
builder.build_return(None);
|
||||
|
||||
if cfg!(debug_assertions) {
|
||||
crate::llvm::build::verify_fn(fn_val);
|
||||
}
|
||||
}
|
||||
|
||||
// roc_realloc
|
||||
{
|
||||
let libc_realloc_val = {
|
||||
|
|
|
|||
|
|
@ -89,15 +89,6 @@ macro_rules! run_jit_function {
|
|||
use roc_gen_llvm::run_roc::RocCallResult;
|
||||
use std::mem::MaybeUninit;
|
||||
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
#[repr(C)]
|
||||
struct Failure {
|
||||
start_line: u32,
|
||||
end_line: u32,
|
||||
start_col: u16,
|
||||
end_col: u16,
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let main: libloading::Symbol<unsafe extern "C" fn(*mut RocCallResult<$ty>)> = $lib
|
||||
.get($main_fn_name.as_bytes())
|
||||
|
|
@ -105,48 +96,8 @@ macro_rules! run_jit_function {
|
|||
.ok_or(format!("Unable to JIT compile `{}`", $main_fn_name))
|
||||
.expect("errored");
|
||||
|
||||
#[repr(C)]
|
||||
struct Failures {
|
||||
failures: *const Failure,
|
||||
count: usize,
|
||||
}
|
||||
|
||||
impl Drop for Failures {
|
||||
fn drop(&mut self) {
|
||||
use std::alloc::{dealloc, Layout};
|
||||
use std::mem;
|
||||
|
||||
unsafe {
|
||||
let layout = Layout::from_size_align_unchecked(
|
||||
mem::size_of::<Failure>(),
|
||||
mem::align_of::<Failure>(),
|
||||
);
|
||||
|
||||
dealloc(self.failures as *mut u8, layout);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let get_expect_failures: libloading::Symbol<unsafe extern "C" fn() -> Failures> = $lib
|
||||
.get(bitcode::UTILS_GET_EXPECT_FAILURES.as_bytes())
|
||||
.ok()
|
||||
.ok_or(format!(
|
||||
"Unable to JIT compile `{}`",
|
||||
bitcode::UTILS_GET_EXPECT_FAILURES
|
||||
))
|
||||
.expect("errored");
|
||||
let mut main_result = MaybeUninit::uninit();
|
||||
|
||||
main(main_result.as_mut_ptr());
|
||||
let failures = get_expect_failures();
|
||||
|
||||
if failures.count > 0 {
|
||||
// TODO tell the user about the failures!
|
||||
let failures =
|
||||
unsafe { core::slice::from_raw_parts(failures.failures, failures.count) };
|
||||
|
||||
panic!("Failed with {} failures. Failures: ", failures.len());
|
||||
}
|
||||
|
||||
match main_result.assume_init().into() {
|
||||
Ok(success) => {
|
||||
|
|
|
|||
|
|
@ -1431,8 +1431,9 @@ fn issue_2365_monomorphize_tag_with_non_empty_ext_var_wrapped() {
|
|||
main = compound {}
|
||||
"#
|
||||
),
|
||||
2, // C
|
||||
u8
|
||||
(0, 2), // Err, C
|
||||
([u8; std::mem::size_of::<RocStr>()], u8),
|
||||
|(err_tag, wrap_tag): ([u8; std::mem::size_of::<RocStr>()], u8)| (wrap_tag, err_tag[0])
|
||||
)
|
||||
}
|
||||
|
||||
|
|
@ -1460,8 +1461,9 @@ fn issue_2365_monomorphize_tag_with_non_empty_ext_var_wrapped_nested() {
|
|||
compound {}
|
||||
"#
|
||||
),
|
||||
2, // C
|
||||
u8
|
||||
(0, 2), // Err, C
|
||||
([u8; std::mem::size_of::<RocStr>()], u8),
|
||||
|(err_tag, wrap_tag): ([u8; std::mem::size_of::<RocStr>()], u8)| (wrap_tag, err_tag[0])
|
||||
)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.279 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
|
||||
let List.283 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.279;
|
||||
ret List.283;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
let Test.7 : {} = Struct {};
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
procedure List.6 (#Attr.2):
|
||||
let List.279 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.279;
|
||||
let List.283 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.283;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.2 : I64 = 41i64;
|
||||
|
|
|
|||
|
|
@ -1,22 +1,22 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.285 : U64 = CallByName List.6 List.75;
|
||||
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
|
||||
if List.281 then
|
||||
let List.283 : {} = CallByName List.60 List.75 List.76;
|
||||
let List.282 : [C {}, C {}] = TagId(1) List.283;
|
||||
ret List.282;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.289 : U64 = CallByName List.6 List.77;
|
||||
let List.285 : Int1 = CallByName Num.22 List.78 List.289;
|
||||
if List.285 then
|
||||
let List.287 : {} = CallByName List.60 List.77 List.78;
|
||||
let List.286 : [C {}, C {}] = TagId(1) List.287;
|
||||
ret List.286;
|
||||
else
|
||||
let List.280 : {} = Struct {};
|
||||
let List.279 : [C {}, C {}] = TagId(0) List.280;
|
||||
ret List.279;
|
||||
let List.284 : {} = Struct {};
|
||||
let List.283 : [C {}, C {}] = TagId(0) List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.288 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.288;
|
||||
let List.292 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.292;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.287 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.287;
|
||||
let List.291 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.291;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,16 @@
|
|||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
let List.279 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.279;
|
||||
procedure List.4 (List.88, List.89):
|
||||
let List.286 : U64 = 1i64;
|
||||
let List.284 : List U8 = CallByName List.65 List.88 List.286;
|
||||
let List.283 : List U8 = CallByName List.66 List.284 List.89;
|
||||
ret List.283;
|
||||
|
||||
procedure List.65 (#Attr.2, #Attr.3):
|
||||
let List.289 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.289;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.288 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.288;
|
||||
|
||||
procedure Test.20 (Test.22):
|
||||
let Test.34 : {U8} = Struct {Test.22};
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
procedure List.6 (#Attr.2):
|
||||
let List.279 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.279;
|
||||
let List.283 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.283;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.190 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,37 +1,37 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.294 : U64 = CallByName List.6 List.75;
|
||||
let List.290 : Int1 = CallByName Num.22 List.76 List.294;
|
||||
if List.290 then
|
||||
let List.292 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.291 : [C {}, C I64] = TagId(1) List.292;
|
||||
ret List.291;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.298 : U64 = CallByName List.6 List.77;
|
||||
let List.294 : Int1 = CallByName Num.22 List.78 List.298;
|
||||
if List.294 then
|
||||
let List.296 : I64 = CallByName List.60 List.77 List.78;
|
||||
let List.295 : [C {}, C I64] = TagId(1) List.296;
|
||||
ret List.295;
|
||||
else
|
||||
let List.289 : {} = Struct {};
|
||||
let List.288 : [C {}, C I64] = TagId(0) List.289;
|
||||
ret List.288;
|
||||
let List.293 : {} = Struct {};
|
||||
let List.292 : [C {}, C I64] = TagId(0) List.293;
|
||||
ret List.292;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.295 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.295;
|
||||
let List.299 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.299;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.293 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.293;
|
||||
let List.297 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.297;
|
||||
|
||||
procedure List.9 (List.201):
|
||||
let List.286 : U64 = 0i64;
|
||||
let List.279 : [C {}, C I64] = CallByName List.2 List.201 List.286;
|
||||
let List.283 : U8 = 1i64;
|
||||
let List.284 : U8 = GetTagId List.279;
|
||||
let List.285 : Int1 = lowlevel Eq List.283 List.284;
|
||||
if List.285 then
|
||||
let List.202 : I64 = UnionAtIndex (Id 1) (Index 0) List.279;
|
||||
let List.280 : [C Int1, C I64] = TagId(1) List.202;
|
||||
ret List.280;
|
||||
procedure List.9 (List.205):
|
||||
let List.290 : U64 = 0i64;
|
||||
let List.283 : [C {}, C I64] = CallByName List.2 List.205 List.290;
|
||||
let List.287 : U8 = 1i64;
|
||||
let List.288 : U8 = GetTagId List.283;
|
||||
let List.289 : Int1 = lowlevel Eq List.287 List.288;
|
||||
if List.289 then
|
||||
let List.206 : I64 = UnionAtIndex (Id 1) (Index 0) List.283;
|
||||
let List.284 : [C Int1, C I64] = TagId(1) List.206;
|
||||
ret List.284;
|
||||
else
|
||||
let List.282 : Int1 = true;
|
||||
let List.281 : [C Int1, C I64] = TagId(0) List.282;
|
||||
ret List.281;
|
||||
let List.286 : Int1 = true;
|
||||
let List.285 : [C Int1, C I64] = TagId(0) List.286;
|
||||
ret List.285;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,16 @@
|
|||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
let List.279 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.279;
|
||||
procedure List.4 (List.88, List.89):
|
||||
let List.286 : U64 = 1i64;
|
||||
let List.284 : List I64 = CallByName List.65 List.88 List.286;
|
||||
let List.283 : List I64 = CallByName List.66 List.284 List.89;
|
||||
ret List.283;
|
||||
|
||||
procedure List.65 (#Attr.2, #Attr.3):
|
||||
let List.289 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.289;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.288 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.288;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [1i64];
|
||||
|
|
|
|||
|
|
@ -1,6 +1,16 @@
|
|||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
let List.279 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.279;
|
||||
procedure List.4 (List.88, List.89):
|
||||
let List.286 : U64 = 1i64;
|
||||
let List.284 : List I64 = CallByName List.65 List.88 List.286;
|
||||
let List.283 : List I64 = CallByName List.66 List.284 List.89;
|
||||
ret List.283;
|
||||
|
||||
procedure List.65 (#Attr.2, #Attr.3):
|
||||
let List.289 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
|
||||
ret List.289;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.288 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
|
||||
ret List.288;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : I64 = 42i64;
|
||||
|
|
|
|||
|
|
@ -1,27 +1,27 @@
|
|||
procedure List.3 (List.83, List.84, List.85):
|
||||
let List.282 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
|
||||
let List.281 : List I64 = StructAtIndex 0 List.282;
|
||||
inc List.281;
|
||||
dec List.282;
|
||||
ret List.281;
|
||||
procedure List.3 (List.85, List.86, List.87):
|
||||
let List.286 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
|
||||
let List.285 : List I64 = StructAtIndex 0 List.286;
|
||||
inc List.285;
|
||||
dec List.286;
|
||||
ret List.285;
|
||||
|
||||
procedure List.57 (List.80, List.81, List.82):
|
||||
let List.288 : U64 = CallByName List.6 List.80;
|
||||
let List.285 : Int1 = CallByName Num.22 List.81 List.288;
|
||||
if List.285 then
|
||||
let List.286 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
|
||||
ret List.286;
|
||||
procedure List.57 (List.82, List.83, List.84):
|
||||
let List.292 : U64 = CallByName List.6 List.82;
|
||||
let List.289 : Int1 = CallByName Num.22 List.83 List.292;
|
||||
if List.289 then
|
||||
let List.290 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
|
||||
ret List.290;
|
||||
else
|
||||
let List.284 : {List I64, I64} = Struct {List.80, List.82};
|
||||
ret List.284;
|
||||
let List.288 : {List I64, I64} = Struct {List.82, List.84};
|
||||
ret List.288;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.280 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.280;
|
||||
let List.284 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.284;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.287 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.287;
|
||||
let List.291 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.291;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,22 +1,22 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.285 : U64 = CallByName List.6 List.75;
|
||||
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
|
||||
if List.281 then
|
||||
let List.283 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.282 : [C {}, C I64] = TagId(1) List.283;
|
||||
ret List.282;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.289 : U64 = CallByName List.6 List.77;
|
||||
let List.285 : Int1 = CallByName Num.22 List.78 List.289;
|
||||
if List.285 then
|
||||
let List.287 : I64 = CallByName List.60 List.77 List.78;
|
||||
let List.286 : [C {}, C I64] = TagId(1) List.287;
|
||||
ret List.286;
|
||||
else
|
||||
let List.280 : {} = Struct {};
|
||||
let List.279 : [C {}, C I64] = TagId(0) List.280;
|
||||
ret List.279;
|
||||
let List.284 : {} = Struct {};
|
||||
let List.283 : [C {}, C I64] = TagId(0) List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.288 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.288;
|
||||
let List.292 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.292;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.287 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.287;
|
||||
let List.291 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.291;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,10 +1,10 @@
|
|||
procedure List.6 (#Attr.2):
|
||||
let List.279 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.279;
|
||||
let List.283 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.283;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.280 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.280;
|
||||
let List.284 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.284;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,26 +1,26 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.285 : U64 = CallByName List.6 List.75;
|
||||
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
|
||||
if List.281 then
|
||||
let List.283 : Str = CallByName List.60 List.75 List.76;
|
||||
let List.282 : [C {}, C Str] = TagId(1) List.283;
|
||||
ret List.282;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.289 : U64 = CallByName List.6 List.77;
|
||||
let List.285 : Int1 = CallByName Num.22 List.78 List.289;
|
||||
if List.285 then
|
||||
let List.287 : Str = CallByName List.60 List.77 List.78;
|
||||
let List.286 : [C {}, C Str] = TagId(1) List.287;
|
||||
ret List.286;
|
||||
else
|
||||
let List.280 : {} = Struct {};
|
||||
let List.279 : [C {}, C Str] = TagId(0) List.280;
|
||||
ret List.279;
|
||||
let List.284 : {} = Struct {};
|
||||
let List.283 : [C {}, C Str] = TagId(0) List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.287 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.287;
|
||||
let List.291 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.291;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.289 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.289;
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.288 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.288;
|
||||
let List.292 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.292;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,28 +1,28 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.285 : U64 = CallByName List.6 List.75;
|
||||
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
|
||||
if List.281 then
|
||||
let List.283 : Str = CallByName List.60 List.75 List.76;
|
||||
let List.282 : [C {}, C Str] = TagId(1) List.283;
|
||||
ret List.282;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.289 : U64 = CallByName List.6 List.77;
|
||||
let List.285 : Int1 = CallByName Num.22 List.78 List.289;
|
||||
if List.285 then
|
||||
let List.287 : Str = CallByName List.60 List.77 List.78;
|
||||
let List.286 : [C {}, C Str] = TagId(1) List.287;
|
||||
ret List.286;
|
||||
else
|
||||
let List.280 : {} = Struct {};
|
||||
let List.279 : [C {}, C Str] = TagId(0) List.280;
|
||||
ret List.279;
|
||||
let List.284 : {} = Struct {};
|
||||
let List.283 : [C {}, C Str] = TagId(0) List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
inc #Attr.2;
|
||||
let List.287 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
let List.291 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.287;
|
||||
ret List.291;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.289 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.289;
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.288 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.288;
|
||||
let List.292 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.292;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,27 +1,27 @@
|
|||
procedure List.3 (List.83, List.84, List.85):
|
||||
let List.280 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
|
||||
let List.279 : List I64 = StructAtIndex 0 List.280;
|
||||
inc List.279;
|
||||
dec List.280;
|
||||
ret List.279;
|
||||
procedure List.3 (List.85, List.86, List.87):
|
||||
let List.284 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
|
||||
let List.283 : List I64 = StructAtIndex 0 List.284;
|
||||
inc List.283;
|
||||
dec List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure List.57 (List.80, List.81, List.82):
|
||||
let List.286 : U64 = CallByName List.6 List.80;
|
||||
let List.283 : Int1 = CallByName Num.22 List.81 List.286;
|
||||
if List.283 then
|
||||
let List.284 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
|
||||
ret List.284;
|
||||
procedure List.57 (List.82, List.83, List.84):
|
||||
let List.290 : U64 = CallByName List.6 List.82;
|
||||
let List.287 : Int1 = CallByName Num.22 List.83 List.290;
|
||||
if List.287 then
|
||||
let List.288 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
|
||||
ret List.288;
|
||||
else
|
||||
let List.282 : {List I64, I64} = Struct {List.80, List.82};
|
||||
ret List.282;
|
||||
let List.286 : {List I64, I64} = Struct {List.82, List.84};
|
||||
ret List.286;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.287 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.287;
|
||||
let List.291 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.291;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.285 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.285;
|
||||
let List.289 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.289;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,16 +1,16 @@
|
|||
procedure List.28 (#Attr.2, #Attr.3):
|
||||
let List.282 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
let List.286 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
let Bool.9 : Int1 = lowlevel ListIsUnique #Attr.2;
|
||||
if Bool.9 then
|
||||
ret List.282;
|
||||
ret List.286;
|
||||
else
|
||||
decref #Attr.2;
|
||||
ret List.282;
|
||||
ret List.286;
|
||||
|
||||
procedure List.54 (List.196):
|
||||
let List.280 : {} = Struct {};
|
||||
let List.279 : List I64 = CallByName List.28 List.196 List.280;
|
||||
ret List.279;
|
||||
procedure List.54 (List.200):
|
||||
let List.284 : {} = Struct {};
|
||||
let List.283 : List I64 = CallByName List.28 List.200 List.284;
|
||||
ret List.283;
|
||||
|
||||
procedure Num.46 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,43 +1,43 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.299 : U64 = CallByName List.6 List.75;
|
||||
let List.295 : Int1 = CallByName Num.22 List.76 List.299;
|
||||
if List.295 then
|
||||
let List.297 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.296 : [C {}, C I64] = TagId(1) List.297;
|
||||
ret List.296;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.303 : U64 = CallByName List.6 List.77;
|
||||
let List.299 : Int1 = CallByName Num.22 List.78 List.303;
|
||||
if List.299 then
|
||||
let List.301 : I64 = CallByName List.60 List.77 List.78;
|
||||
let List.300 : [C {}, C I64] = TagId(1) List.301;
|
||||
ret List.300;
|
||||
else
|
||||
let List.294 : {} = Struct {};
|
||||
let List.293 : [C {}, C I64] = TagId(0) List.294;
|
||||
ret List.293;
|
||||
let List.298 : {} = Struct {};
|
||||
let List.297 : [C {}, C I64] = TagId(0) List.298;
|
||||
ret List.297;
|
||||
|
||||
procedure List.3 (List.83, List.84, List.85):
|
||||
let List.283 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
|
||||
let List.282 : List I64 = StructAtIndex 0 List.283;
|
||||
inc List.282;
|
||||
dec List.283;
|
||||
ret List.282;
|
||||
procedure List.3 (List.85, List.86, List.87):
|
||||
let List.287 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
|
||||
let List.286 : List I64 = StructAtIndex 0 List.287;
|
||||
inc List.286;
|
||||
dec List.287;
|
||||
ret List.286;
|
||||
|
||||
procedure List.57 (List.80, List.81, List.82):
|
||||
let List.305 : U64 = CallByName List.6 List.80;
|
||||
let List.302 : Int1 = CallByName Num.22 List.81 List.305;
|
||||
if List.302 then
|
||||
let List.303 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
|
||||
ret List.303;
|
||||
procedure List.57 (List.82, List.83, List.84):
|
||||
let List.309 : U64 = CallByName List.6 List.82;
|
||||
let List.306 : Int1 = CallByName Num.22 List.83 List.309;
|
||||
if List.306 then
|
||||
let List.307 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
|
||||
ret List.307;
|
||||
else
|
||||
let List.301 : {List I64, I64} = Struct {List.80, List.82};
|
||||
ret List.301;
|
||||
let List.305 : {List I64, I64} = Struct {List.82, List.84};
|
||||
ret List.305;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.306 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.306;
|
||||
let List.310 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.310;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.307 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.307;
|
||||
let List.311 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.311;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.304 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.304;
|
||||
let List.308 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.308;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
|
|
@ -1,43 +1,43 @@
|
|||
procedure List.2 (List.75, List.76):
|
||||
let List.299 : U64 = CallByName List.6 List.75;
|
||||
let List.295 : Int1 = CallByName Num.22 List.76 List.299;
|
||||
if List.295 then
|
||||
let List.297 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.296 : [C {}, C I64] = TagId(1) List.297;
|
||||
ret List.296;
|
||||
procedure List.2 (List.77, List.78):
|
||||
let List.303 : U64 = CallByName List.6 List.77;
|
||||
let List.299 : Int1 = CallByName Num.22 List.78 List.303;
|
||||
if List.299 then
|
||||
let List.301 : I64 = CallByName List.60 List.77 List.78;
|
||||
let List.300 : [C {}, C I64] = TagId(1) List.301;
|
||||
ret List.300;
|
||||
else
|
||||
let List.294 : {} = Struct {};
|
||||
let List.293 : [C {}, C I64] = TagId(0) List.294;
|
||||
ret List.293;
|
||||
let List.298 : {} = Struct {};
|
||||
let List.297 : [C {}, C I64] = TagId(0) List.298;
|
||||
ret List.297;
|
||||
|
||||
procedure List.3 (List.83, List.84, List.85):
|
||||
let List.283 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
|
||||
let List.282 : List I64 = StructAtIndex 0 List.283;
|
||||
inc List.282;
|
||||
dec List.283;
|
||||
ret List.282;
|
||||
procedure List.3 (List.85, List.86, List.87):
|
||||
let List.287 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
|
||||
let List.286 : List I64 = StructAtIndex 0 List.287;
|
||||
inc List.286;
|
||||
dec List.287;
|
||||
ret List.286;
|
||||
|
||||
procedure List.57 (List.80, List.81, List.82):
|
||||
let List.305 : U64 = CallByName List.6 List.80;
|
||||
let List.302 : Int1 = CallByName Num.22 List.81 List.305;
|
||||
if List.302 then
|
||||
let List.303 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
|
||||
ret List.303;
|
||||
procedure List.57 (List.82, List.83, List.84):
|
||||
let List.309 : U64 = CallByName List.6 List.82;
|
||||
let List.306 : Int1 = CallByName Num.22 List.83 List.309;
|
||||
if List.306 then
|
||||
let List.307 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
|
||||
ret List.307;
|
||||
else
|
||||
let List.301 : {List I64, I64} = Struct {List.80, List.82};
|
||||
ret List.301;
|
||||
let List.305 : {List I64, I64} = Struct {List.82, List.84};
|
||||
ret List.305;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.306 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.306;
|
||||
let List.310 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.310;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.307 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.307;
|
||||
let List.311 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.311;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.304 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.304;
|
||||
let List.308 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.308;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue