mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-11 18:58:24 +03:00
Merge remote-tracking branch 'origin/main' into remove-nat
This commit is contained in:
commit
aabd95404f
@ -24,6 +24,9 @@ pub const RocDec = extern struct {
|
||||
pub const one_point_zero_i128: i128 = math.pow(i128, 10, RocDec.decimal_places);
|
||||
pub const one_point_zero: RocDec = .{ .num = one_point_zero_i128 };
|
||||
|
||||
pub const two_point_zero: RocDec = RocDec.add(RocDec.one_point_zero, RocDec.one_point_zero);
|
||||
pub const zero_point_five: RocDec = RocDec.div(RocDec.one_point_zero, RocDec.two_point_zero);
|
||||
|
||||
pub fn fromU64(num: u64) RocDec {
|
||||
return .{ .num = num * one_point_zero_i128 };
|
||||
}
|
||||
@ -340,6 +343,54 @@ pub const RocDec = extern struct {
|
||||
}
|
||||
}
|
||||
|
||||
fn trunc(self: RocDec) RocDec {
|
||||
return RocDec.sub(self, self.fract());
|
||||
}
|
||||
|
||||
fn fract(self: RocDec) RocDec {
|
||||
const sign = std.math.sign(self.num);
|
||||
const digits = @mod(sign * self.num, RocDec.one_point_zero.num);
|
||||
|
||||
return RocDec{ .num = sign * digits };
|
||||
}
|
||||
|
||||
// Returns the nearest integer to self. If a value is half-way between two integers, round away from 0.0.
|
||||
fn round(arg1: RocDec) RocDec {
|
||||
// this rounds towards zero
|
||||
const tmp = arg1.trunc();
|
||||
|
||||
const sign = std.math.sign(arg1.num);
|
||||
const abs_fract = sign * arg1.fract().num;
|
||||
|
||||
if (abs_fract >= RocDec.zero_point_five.num) {
|
||||
return RocDec.add(tmp, RocDec{ .num = sign * RocDec.one_point_zero.num });
|
||||
} else {
|
||||
return tmp;
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the largest integer less than or equal to itself
|
||||
fn floor(arg1: RocDec) RocDec {
|
||||
const tmp = arg1.trunc();
|
||||
|
||||
if (arg1.num < 0 and arg1.fract().num != 0) {
|
||||
return RocDec.sub(tmp, RocDec.one_point_zero);
|
||||
} else {
|
||||
return tmp;
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the smallest integer greater than or equal to itself
|
||||
fn ceiling(arg1: RocDec) RocDec {
|
||||
const tmp = arg1.trunc();
|
||||
|
||||
if (arg1.num > 0 and arg1.fract().num != 0) {
|
||||
return RocDec.add(tmp, RocDec.one_point_zero);
|
||||
} else {
|
||||
return tmp;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn mul(self: RocDec, other: RocDec) RocDec {
|
||||
const answer = RocDec.mulWithOverflow(self, other);
|
||||
|
||||
@ -1195,6 +1246,118 @@ test "log: 1" {
|
||||
try expectEqual(RocDec.fromU64(0), RocDec.log(RocDec.fromU64(1)));
|
||||
}
|
||||
|
||||
test "fract: 0" {
|
||||
var roc_str = RocStr.init("0", 1);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 0 }, dec.fract());
|
||||
}
|
||||
|
||||
test "fract: 1" {
|
||||
var roc_str = RocStr.init("1", 1);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 0 }, dec.fract());
|
||||
}
|
||||
|
||||
test "fract: 123.45" {
|
||||
var roc_str = RocStr.init("123.45", 6);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 450000000000000000 }, dec.fract());
|
||||
}
|
||||
|
||||
test "fract: -123.45" {
|
||||
var roc_str = RocStr.init("-123.45", 7);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = -450000000000000000 }, dec.fract());
|
||||
}
|
||||
|
||||
test "fract: .45" {
|
||||
var roc_str = RocStr.init(".45", 3);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 450000000000000000 }, dec.fract());
|
||||
}
|
||||
|
||||
test "fract: -0.00045" {
|
||||
const dec: RocDec = .{ .num = -450000000000000 };
|
||||
const res = dec.fract();
|
||||
|
||||
try expectEqual(dec.num, res.num);
|
||||
}
|
||||
|
||||
test "trunc: 0" {
|
||||
var roc_str = RocStr.init("0", 1);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 0 }, dec.trunc());
|
||||
}
|
||||
|
||||
test "trunc: 1" {
|
||||
var roc_str = RocStr.init("1", 1);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec.one_point_zero, dec.trunc());
|
||||
}
|
||||
|
||||
test "trunc: 123.45" {
|
||||
var roc_str = RocStr.init("123.45", 6);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.trunc());
|
||||
}
|
||||
|
||||
test "trunc: -123.45" {
|
||||
var roc_str = RocStr.init("-123.45", 7);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.trunc());
|
||||
}
|
||||
|
||||
test "trunc: .45" {
|
||||
var roc_str = RocStr.init(".45", 3);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 0 }, dec.trunc());
|
||||
}
|
||||
|
||||
test "trunc: -0.00045" {
|
||||
const dec: RocDec = .{ .num = -450000000000000 };
|
||||
const res = dec.trunc();
|
||||
|
||||
try expectEqual(RocDec{ .num = 0 }, res);
|
||||
}
|
||||
|
||||
test "round: 123.45" {
|
||||
var roc_str = RocStr.init("123.45", 6);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.round());
|
||||
}
|
||||
|
||||
test "round: -123.45" {
|
||||
var roc_str = RocStr.init("-123.45", 7);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.round());
|
||||
}
|
||||
|
||||
test "round: 0.5" {
|
||||
var roc_str = RocStr.init("0.5", 3);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec.one_point_zero, dec.round());
|
||||
}
|
||||
|
||||
test "round: -0.5" {
|
||||
var roc_str = RocStr.init("-0.5", 4);
|
||||
var dec = RocDec.fromStr(roc_str).?;
|
||||
|
||||
try expectEqual(RocDec{ .num = -1000000000000000000 }, dec.round());
|
||||
}
|
||||
|
||||
// exports
|
||||
|
||||
pub fn fromStr(arg: RocStr) callconv(.C) num_.NumParseResult(i128) {
|
||||
@ -1342,3 +1505,30 @@ pub fn mulOrPanicC(arg1: RocDec, arg2: RocDec) callconv(.C) RocDec {
|
||||
pub fn mulSaturatedC(arg1: RocDec, arg2: RocDec) callconv(.C) RocDec {
|
||||
return @call(.always_inline, RocDec.mulSaturated, .{ arg1, arg2 });
|
||||
}
|
||||
|
||||
pub fn exportRound(comptime T: type, comptime name: []const u8) void {
|
||||
comptime var f = struct {
|
||||
fn func(input: RocDec) callconv(.C) T {
|
||||
return @as(T, @intCast(@divFloor(input.round().num, RocDec.one_point_zero_i128)));
|
||||
}
|
||||
}.func;
|
||||
@export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
|
||||
}
|
||||
|
||||
pub fn exportFloor(comptime T: type, comptime name: []const u8) void {
|
||||
comptime var f = struct {
|
||||
fn func(input: RocDec) callconv(.C) T {
|
||||
return @as(T, @intCast(@divFloor(input.floor().num, RocDec.one_point_zero_i128)));
|
||||
}
|
||||
}.func;
|
||||
@export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
|
||||
}
|
||||
|
||||
pub fn exportCeiling(comptime T: type, comptime name: []const u8) void {
|
||||
comptime var f = struct {
|
||||
fn func(input: RocDec) callconv(.C) T {
|
||||
return @as(T, @intCast(@divFloor(input.ceiling().num, RocDec.one_point_zero_i128)));
|
||||
}
|
||||
}.func;
|
||||
@export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
|
||||
}
|
||||
|
@ -52,6 +52,10 @@ comptime {
|
||||
|
||||
inline for (INTEGERS) |T| {
|
||||
dec.exportFromInt(T, ROC_BUILTINS ++ ".dec.from_int.");
|
||||
|
||||
dec.exportRound(T, ROC_BUILTINS ++ ".dec.round.");
|
||||
dec.exportFloor(T, ROC_BUILTINS ++ ".dec.floor.");
|
||||
dec.exportCeiling(T, ROC_BUILTINS ++ ".dec.ceiling.");
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -924,13 +924,21 @@ divCeilChecked = \a, b ->
|
||||
## Num.divTrunc 8 -3
|
||||
## ```
|
||||
divTrunc : Int a, Int a -> Int a
|
||||
divTrunc = \a, b ->
|
||||
if Num.isZero b then
|
||||
crash "Integer division by 0!"
|
||||
else
|
||||
Num.divTruncUnchecked a b
|
||||
|
||||
divTruncChecked : Int a, Int a -> Result (Int a) [DivByZero]
|
||||
divTruncChecked = \a, b ->
|
||||
if Num.isZero b then
|
||||
Err DivByZero
|
||||
else
|
||||
Ok (Num.divTrunc a b)
|
||||
Ok (Num.divTruncUnchecked a b)
|
||||
|
||||
## traps (hardware fault) when given zero as the second argument.
|
||||
divTruncUnchecked : Int a, Int a -> Int a
|
||||
|
||||
## Obtains the remainder (truncating modulo) from the division of two integers.
|
||||
##
|
||||
@ -945,13 +953,21 @@ divTruncChecked = \a, b ->
|
||||
## Num.rem -8 -3
|
||||
## ```
|
||||
rem : Int a, Int a -> Int a
|
||||
rem = \a, b ->
|
||||
if Num.isZero b then
|
||||
crash "Integer division by 0!"
|
||||
else
|
||||
Num.remUnchecked a b
|
||||
|
||||
remChecked : Int a, Int a -> Result (Int a) [DivByZero]
|
||||
remChecked = \a, b ->
|
||||
if Num.isZero b then
|
||||
Err DivByZero
|
||||
else
|
||||
Ok (Num.rem a b)
|
||||
Ok (Num.remUnchecked a b)
|
||||
|
||||
## traps (hardware fault) when given zero as the second argument.
|
||||
remUnchecked : Int a, Int a -> Int a
|
||||
|
||||
isMultipleOf : Int a, Int a -> Bool
|
||||
|
||||
|
@ -415,6 +415,9 @@ pub const DEC_SUB_WITH_OVERFLOW: &str = "roc_builtins.dec.sub_with_overflow";
|
||||
pub const DEC_TAN: &str = "roc_builtins.dec.tan";
|
||||
pub const DEC_TO_I128: &str = "roc_builtins.dec.to_i128";
|
||||
pub const DEC_TO_STR: &str = "roc_builtins.dec.to_str";
|
||||
pub const DEC_ROUND: IntrinsicName = int_intrinsic!("roc_builtins.dec.round");
|
||||
pub const DEC_FLOOR: IntrinsicName = int_intrinsic!("roc_builtins.dec.floor");
|
||||
pub const DEC_CEILING: IntrinsicName = int_intrinsic!("roc_builtins.dec.ceiling");
|
||||
|
||||
pub const UTILS_DBG_IMPL: &str = "roc_builtins.utils.dbg_impl";
|
||||
pub const UTILS_TEST_PANIC: &str = "roc_builtins.utils.test_panic";
|
||||
|
@ -171,9 +171,9 @@ map_symbol_to_lowlevel_and_arity! {
|
||||
NumLte; NUM_LTE; 2,
|
||||
NumCompare; NUM_COMPARE; 2,
|
||||
NumDivFrac; NUM_DIV_FRAC; 2,
|
||||
NumDivTruncUnchecked; NUM_DIV_TRUNC; 2,
|
||||
NumDivTruncUnchecked; NUM_DIV_TRUNC_UNCHECKED; 2,
|
||||
NumDivCeilUnchecked; NUM_DIV_CEIL; 2,
|
||||
NumRemUnchecked; NUM_REM; 2,
|
||||
NumRemUnchecked; NUM_REM_UNCHECKED; 2,
|
||||
NumIsMultipleOf; NUM_IS_MULTIPLE_OF; 2,
|
||||
NumAbs; NUM_ABS; 1,
|
||||
NumNeg; NUM_NEG; 1,
|
||||
|
@ -2600,10 +2600,38 @@ fn flatten_str_lines<'a>(
|
||||
fn desugar_str_segments(var_store: &mut VarStore, segments: Vec<StrSegment>) -> Expr {
|
||||
use StrSegment::*;
|
||||
|
||||
let n = segments.len();
|
||||
let mut iter = segments.into_iter().rev();
|
||||
let mut loc_expr = match iter.next() {
|
||||
Some(Plaintext(string)) => Loc::at(Region::zero(), Expr::Str(string)),
|
||||
Some(Interpolation(loc_expr)) => loc_expr,
|
||||
Some(Interpolation(loc_expr)) => {
|
||||
if n == 1 {
|
||||
// We concat with the empty string to ensure a type error when loc_expr is not a string
|
||||
let empty_string = Loc::at(Region::zero(), Expr::Str("".into()));
|
||||
|
||||
let fn_expr = Loc::at(
|
||||
Region::zero(),
|
||||
Expr::Var(Symbol::STR_CONCAT, var_store.fresh()),
|
||||
);
|
||||
let expr = Expr::Call(
|
||||
Box::new((
|
||||
var_store.fresh(),
|
||||
fn_expr,
|
||||
var_store.fresh(),
|
||||
var_store.fresh(),
|
||||
)),
|
||||
vec![
|
||||
(var_store.fresh(), empty_string),
|
||||
(var_store.fresh(), loc_expr),
|
||||
],
|
||||
CalledVia::StringInterpolation,
|
||||
);
|
||||
|
||||
Loc::at(Region::zero(), expr)
|
||||
} else {
|
||||
loc_expr
|
||||
}
|
||||
}
|
||||
None => {
|
||||
// No segments? Empty string!
|
||||
|
||||
|
@ -3299,7 +3299,7 @@ impl<
|
||||
let elem_layout = arg_layouts[1];
|
||||
|
||||
// List alignment argument (u32).
|
||||
self.load_layout_alignment(*ret_layout, Symbol::DEV_TMP);
|
||||
self.load_layout_alignment(elem_layout, Symbol::DEV_TMP);
|
||||
|
||||
// Have to pass the input element by pointer, so put it on the stack and load it's address.
|
||||
self.storage_manager
|
||||
|
@ -1106,30 +1106,36 @@ trait Backend<'a> {
|
||||
self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
|
||||
}
|
||||
|
||||
LowLevel::NumRound => {
|
||||
let repr = self.interner().get_repr(*ret_layout);
|
||||
let LayoutRepr::Builtin(Builtin::Int(int_width)) = repr else {
|
||||
unreachable!("invalid return layout for NumRound")
|
||||
};
|
||||
|
||||
let intrinsic = match arg_layouts[0] {
|
||||
Layout::F32 => &bitcode::NUM_ROUND_F32[int_width],
|
||||
Layout::F64 => &bitcode::NUM_ROUND_F64[int_width],
|
||||
Layout::DEC => &bitcode::DEC_ROUND[int_width],
|
||||
_ => unreachable!("invalid layout for NumRound"),
|
||||
};
|
||||
|
||||
self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
|
||||
}
|
||||
|
||||
LowLevel::NumFloor => {
|
||||
let repr = self.interner().get_repr(*ret_layout);
|
||||
let LayoutRepr::Builtin(Builtin::Int(int_width)) = repr else {
|
||||
unreachable!("invalid return layout for NumFloor")
|
||||
};
|
||||
|
||||
match arg_layouts[0] {
|
||||
Layout::F32 => self.build_fn_call(
|
||||
sym,
|
||||
bitcode::NUM_FLOOR_F32[int_width].to_string(),
|
||||
args,
|
||||
arg_layouts,
|
||||
ret_layout,
|
||||
),
|
||||
Layout::F64 => self.build_fn_call(
|
||||
sym,
|
||||
bitcode::NUM_FLOOR_F64[int_width].to_string(),
|
||||
args,
|
||||
arg_layouts,
|
||||
ret_layout,
|
||||
),
|
||||
Layout::DEC => todo!("NumFloor for decimals"),
|
||||
let intrinsic = match arg_layouts[0] {
|
||||
Layout::F32 => &bitcode::NUM_FLOOR_F32[int_width],
|
||||
Layout::F64 => &bitcode::NUM_FLOOR_F64[int_width],
|
||||
Layout::DEC => &bitcode::DEC_FLOOR[int_width],
|
||||
_ => unreachable!("invalid layout for NumFloor"),
|
||||
}
|
||||
};
|
||||
|
||||
self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
|
||||
}
|
||||
|
||||
LowLevel::NumCeiling => {
|
||||
@ -1138,24 +1144,14 @@ trait Backend<'a> {
|
||||
unreachable!("invalid return layout for NumCeiling")
|
||||
};
|
||||
|
||||
match arg_layouts[0] {
|
||||
Layout::F32 => self.build_fn_call(
|
||||
sym,
|
||||
bitcode::NUM_CEILING_F32[int_width].to_string(),
|
||||
args,
|
||||
arg_layouts,
|
||||
ret_layout,
|
||||
),
|
||||
Layout::F64 => self.build_fn_call(
|
||||
sym,
|
||||
bitcode::NUM_CEILING_F64[int_width].to_string(),
|
||||
args,
|
||||
arg_layouts,
|
||||
ret_layout,
|
||||
),
|
||||
Layout::DEC => todo!("NumCeiling for decimals"),
|
||||
let intrinsic = match arg_layouts[0] {
|
||||
Layout::F32 => &bitcode::NUM_CEILING_F32[int_width],
|
||||
Layout::F64 => &bitcode::NUM_CEILING_F64[int_width],
|
||||
Layout::DEC => &bitcode::DEC_CEILING[int_width],
|
||||
_ => unreachable!("invalid layout for NumCeiling"),
|
||||
}
|
||||
};
|
||||
|
||||
self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
|
||||
}
|
||||
|
||||
LowLevel::NumSub => {
|
||||
@ -1494,13 +1490,6 @@ trait Backend<'a> {
|
||||
|
||||
self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
|
||||
}
|
||||
LowLevel::NumRound => self.build_fn_call(
|
||||
sym,
|
||||
bitcode::NUM_ROUND_F64[IntWidth::I64].to_string(),
|
||||
args,
|
||||
arg_layouts,
|
||||
ret_layout,
|
||||
),
|
||||
LowLevel::ListLen => {
|
||||
debug_assert_eq!(
|
||||
1,
|
||||
|
@ -2141,11 +2141,13 @@ fn build_dec_unary_op<'a, 'ctx>(
|
||||
_layout_interner: &STLayoutInterner<'a>,
|
||||
_parent: FunctionValue<'ctx>,
|
||||
arg: BasicValueEnum<'ctx>,
|
||||
_return_layout: InLayout<'a>,
|
||||
return_layout: InLayout<'a>,
|
||||
op: LowLevel,
|
||||
) -> BasicValueEnum<'ctx> {
|
||||
use roc_module::low_level::LowLevel::*;
|
||||
|
||||
let int_width = || return_layout.to_int_width();
|
||||
|
||||
match op {
|
||||
NumAbs => dec_unary_op(env, bitcode::DEC_ABS, arg),
|
||||
NumAcos => dec_unary_op(env, bitcode::DEC_ACOS, arg),
|
||||
@ -2155,6 +2157,10 @@ fn build_dec_unary_op<'a, 'ctx>(
|
||||
NumSin => dec_unary_op(env, bitcode::DEC_SIN, arg),
|
||||
NumTan => dec_unary_op(env, bitcode::DEC_TAN, arg),
|
||||
|
||||
NumRound => dec_unary_op(env, &bitcode::DEC_ROUND[int_width()], arg),
|
||||
NumFloor => dec_unary_op(env, &bitcode::DEC_FLOOR[int_width()], arg),
|
||||
NumCeiling => dec_unary_op(env, &bitcode::DEC_CEILING[int_width()], arg),
|
||||
|
||||
_ => {
|
||||
unreachable!("Unrecognized dec unary operation: {:?}", op);
|
||||
}
|
||||
@ -2636,42 +2642,39 @@ fn build_float_unary_op<'a, 'ctx>(
|
||||
LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
|
||||
_ => internal_error!("Ceiling return layout is not int: {:?}", layout),
|
||||
};
|
||||
match float_width {
|
||||
FloatWidth::F32 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_CEILING_F32[int_width])
|
||||
}
|
||||
FloatWidth::F64 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_CEILING_F64[int_width])
|
||||
}
|
||||
}
|
||||
|
||||
let intrinsic = match float_width {
|
||||
FloatWidth::F32 => &bitcode::NUM_CEILING_F32[int_width],
|
||||
FloatWidth::F64 => &bitcode::NUM_CEILING_F64[int_width],
|
||||
};
|
||||
|
||||
call_bitcode_fn(env, &[arg.into()], intrinsic)
|
||||
}
|
||||
NumFloor => {
|
||||
let int_width = match layout_interner.get_repr(layout) {
|
||||
LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
|
||||
_ => internal_error!("Floor return layout is not int: {:?}", layout),
|
||||
};
|
||||
match float_width {
|
||||
FloatWidth::F32 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_FLOOR_F32[int_width])
|
||||
}
|
||||
FloatWidth::F64 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_FLOOR_F64[int_width])
|
||||
}
|
||||
}
|
||||
|
||||
let intrinsic = match float_width {
|
||||
FloatWidth::F32 => &bitcode::NUM_FLOOR_F32[int_width],
|
||||
FloatWidth::F64 => &bitcode::NUM_FLOOR_F64[int_width],
|
||||
};
|
||||
|
||||
call_bitcode_fn(env, &[arg.into()], intrinsic)
|
||||
}
|
||||
NumRound => {
|
||||
let int_width = match layout_interner.get_repr(layout) {
|
||||
LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
|
||||
_ => internal_error!("Round return layout is not int: {:?}", layout),
|
||||
};
|
||||
match float_width {
|
||||
FloatWidth::F32 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_ROUND_F32[int_width])
|
||||
}
|
||||
FloatWidth::F64 => {
|
||||
call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_ROUND_F64[int_width])
|
||||
}
|
||||
}
|
||||
|
||||
let intrinsic = match float_width {
|
||||
FloatWidth::F32 => &bitcode::NUM_ROUND_F32[int_width],
|
||||
FloatWidth::F64 => &bitcode::NUM_ROUND_F64[int_width],
|
||||
};
|
||||
|
||||
call_bitcode_fn(env, &[arg.into()], intrinsic)
|
||||
}
|
||||
NumIsNan => call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_IS_NAN[float_width]),
|
||||
NumIsInfinite => {
|
||||
|
@ -1640,6 +1640,7 @@ impl<'a> LowLevelCall<'a> {
|
||||
match arg_type {
|
||||
F32 => self.load_args_and_call_zig(backend, &bitcode::NUM_ROUND_F32[width]),
|
||||
F64 => self.load_args_and_call_zig(backend, &bitcode::NUM_ROUND_F64[width]),
|
||||
Decimal => self.load_args_and_call_zig(backend, &bitcode::DEC_ROUND[width]),
|
||||
_ => internal_error!("Invalid argument type for round: {:?}", arg_type),
|
||||
}
|
||||
}
|
||||
@ -1647,6 +1648,14 @@ impl<'a> LowLevelCall<'a> {
|
||||
self.load_args(backend);
|
||||
let arg_type = CodeGenNumType::for_symbol(backend, self.arguments[0]);
|
||||
let ret_type = CodeGenNumType::from(self.ret_layout);
|
||||
|
||||
let width = match ret_type {
|
||||
CodeGenNumType::I32 => IntWidth::I32,
|
||||
CodeGenNumType::I64 => IntWidth::I64,
|
||||
CodeGenNumType::I128 => todo!("{:?} for I128", self.lowlevel),
|
||||
_ => internal_error!("Invalid return type for round: {:?}", ret_type),
|
||||
};
|
||||
|
||||
match (arg_type, self.lowlevel) {
|
||||
(F32, NumCeiling) => {
|
||||
backend.code_builder.f32_ceil();
|
||||
@ -1654,14 +1663,21 @@ impl<'a> LowLevelCall<'a> {
|
||||
(F64, NumCeiling) => {
|
||||
backend.code_builder.f64_ceil();
|
||||
}
|
||||
(Decimal, NumCeiling) => {
|
||||
return self.load_args_and_call_zig(backend, &bitcode::DEC_CEILING[width]);
|
||||
}
|
||||
(F32, NumFloor) => {
|
||||
backend.code_builder.f32_floor();
|
||||
}
|
||||
(F64, NumFloor) => {
|
||||
backend.code_builder.f64_floor();
|
||||
}
|
||||
(Decimal, NumFloor) => {
|
||||
return self.load_args_and_call_zig(backend, &bitcode::DEC_FLOOR[width]);
|
||||
}
|
||||
_ => internal_error!("Invalid argument type for ceiling: {:?}", arg_type),
|
||||
}
|
||||
|
||||
match (ret_type, arg_type) {
|
||||
// TODO: unsigned truncation
|
||||
(I32, F32) => backend.code_builder.i32_trunc_s_f32(),
|
||||
|
@ -75,19 +75,36 @@ impl Wasm32Sized for isize {
|
||||
const ALIGN_OF_WASM: usize = 4;
|
||||
}
|
||||
|
||||
const fn next_multiple_of(lhs: usize, rhs: usize) -> usize {
|
||||
if lhs == 0 {
|
||||
return lhs;
|
||||
}
|
||||
|
||||
match lhs % rhs {
|
||||
0 => lhs,
|
||||
r => lhs + (rhs - r),
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Wasm32Sized, U: Wasm32Sized> Wasm32Sized for (T, U) {
|
||||
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM;
|
||||
const SIZE_OF_WASM: usize =
|
||||
next_multiple_of(T::SIZE_OF_WASM + U::SIZE_OF_WASM, Self::ALIGN_OF_WASM);
|
||||
const ALIGN_OF_WASM: usize = max(&[T::ALIGN_OF_WASM, U::ALIGN_OF_WASM]);
|
||||
}
|
||||
|
||||
impl<T: Wasm32Sized, U: Wasm32Sized, V: Wasm32Sized> Wasm32Sized for (T, U, V) {
|
||||
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM;
|
||||
const SIZE_OF_WASM: usize = next_multiple_of(
|
||||
T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM,
|
||||
Self::ALIGN_OF_WASM,
|
||||
);
|
||||
const ALIGN_OF_WASM: usize = max(&[T::ALIGN_OF_WASM, U::ALIGN_OF_WASM, V::ALIGN_OF_WASM]);
|
||||
}
|
||||
|
||||
impl<T: Wasm32Sized, U: Wasm32Sized, V: Wasm32Sized, W: Wasm32Sized> Wasm32Sized for (T, U, V, W) {
|
||||
const SIZE_OF_WASM: usize =
|
||||
T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM + W::SIZE_OF_WASM;
|
||||
const SIZE_OF_WASM: usize = next_multiple_of(
|
||||
T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM + W::SIZE_OF_WASM,
|
||||
Self::ALIGN_OF_WASM,
|
||||
);
|
||||
const ALIGN_OF_WASM: usize = max(&[
|
||||
T::ALIGN_OF_WASM,
|
||||
U::ALIGN_OF_WASM,
|
||||
|
@ -304,8 +304,8 @@ map_symbol_to_lowlevel! {
|
||||
NumCompare <= NUM_COMPARE;
|
||||
NumDivFrac <= NUM_DIV_FRAC;
|
||||
NumDivCeilUnchecked <= NUM_DIV_CEIL;
|
||||
NumDivTruncUnchecked <= NUM_DIV_TRUNC;
|
||||
NumRemUnchecked <= NUM_REM;
|
||||
NumDivTruncUnchecked <= NUM_DIV_TRUNC_UNCHECKED;
|
||||
NumRemUnchecked <= NUM_REM_UNCHECKED;
|
||||
NumIsMultipleOf <= NUM_IS_MULTIPLE_OF;
|
||||
NumAbs <= NUM_ABS;
|
||||
NumNeg <= NUM_NEG;
|
||||
|
@ -1262,6 +1262,12 @@ define_builtins! {
|
||||
150 NUM_BITWISE_NOT: "bitwiseNot"
|
||||
151 NUM_INT_CAST: "intCast"
|
||||
152 NUM_IS_APPROX_EQ: "isApproxEq"
|
||||
153 NUM_BYTES_TO_U16_LOWLEVEL: "bytesToU16Lowlevel"
|
||||
154 NUM_BYTES_TO_U32_LOWLEVEL: "bytesToU32Lowlevel"
|
||||
155 NUM_BYTES_TO_U64_LOWLEVEL: "bytesToU64Lowlevel"
|
||||
156 NUM_BYTES_TO_U128_LOWLEVEL: "bytesToU128Lowlevel"
|
||||
157 NUM_DIV_TRUNC_UNCHECKED: "divTruncUnchecked" // traps on division by zero
|
||||
158 NUM_REM_UNCHECKED: "remUnchecked" // traps on division by zero
|
||||
}
|
||||
4 BOOL: "Bool" => {
|
||||
0 BOOL_BOOL: "Bool" exposed_type=true // the Bool.Bool type alias
|
||||
|
@ -910,6 +910,25 @@ fn list_prepend_big_list() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn list_prepend_record() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r"
|
||||
payment1 : { amount: Dec, date: [RD I32] }
|
||||
payment1 = { amount: 1dec, date: (RD 1000) }
|
||||
payment2 : { amount: Dec, date: [RD I32] }
|
||||
payment2 = { amount: 2dec, date: (RD 1001) }
|
||||
|
||||
List.prepend [payment2] payment1
|
||||
"
|
||||
),
|
||||
RocList::from_slice(&[(RocDec::from(1), 1000i32), (RocDec::from(2), 1001i32),]),
|
||||
RocList<(RocDec, i32)>
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn list_walk_backwards_empty_all_inline() {
|
||||
|
@ -1154,19 +1154,20 @@ fn gen_div_u64() {
|
||||
assert_evals_to!("1000u64 // 10", 100, u64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
#[should_panic(expected = r#"User crash with message: "Integer division by 0!"#)]
|
||||
fn gen_div_by_zero_i64() {
|
||||
assert_evals_to!("1i64 // 0", 100, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn gen_div_checked_i64() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r"
|
||||
when Num.divTruncChecked 1000 10 is
|
||||
Ok val -> val
|
||||
Err _ -> -1
|
||||
"
|
||||
),
|
||||
100,
|
||||
i64
|
||||
"Num.divTruncChecked 1000 10",
|
||||
RocResult::ok(100),
|
||||
RocResult<i64, ()>
|
||||
);
|
||||
}
|
||||
|
||||
@ -1174,15 +1175,9 @@ fn gen_div_checked_i64() {
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn gen_div_checked_by_zero_i64() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r"
|
||||
when Num.divTruncChecked 1000 0 is
|
||||
Err DivByZero -> 99
|
||||
_ -> -24
|
||||
"
|
||||
),
|
||||
99,
|
||||
i64
|
||||
"Num.divTruncChecked 1000 0",
|
||||
RocResult::err(()),
|
||||
RocResult<i64, ()>
|
||||
);
|
||||
}
|
||||
|
||||
@ -1192,19 +1187,30 @@ fn gen_rem_i64() {
|
||||
assert_evals_to!("Num.rem 8 3", 2, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
#[should_panic(expected = r#"User crash with message: "Integer division by 0!"#)]
|
||||
fn gen_rem_div_by_zero_i64() {
|
||||
assert_evals_to!("Num.rem 42 0", 100, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn gen_rem_checked_i64() {
|
||||
assert_evals_to!(
|
||||
"Num.remChecked 42 40",
|
||||
RocResult::ok(2),
|
||||
RocResult<i64, ()>
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn gen_rem_checked_div_by_zero_i64() {
|
||||
assert_evals_to!(
|
||||
indoc!(
|
||||
r"
|
||||
when Num.remChecked 8 0 is
|
||||
Err DivByZero -> 4
|
||||
Ok _ -> -23
|
||||
"
|
||||
),
|
||||
4,
|
||||
i64
|
||||
"Num.remChecked 8 0",
|
||||
RocResult::err(()),
|
||||
RocResult<i64, ()>
|
||||
);
|
||||
}
|
||||
|
||||
@ -1825,15 +1831,56 @@ fn pow() {
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn ceiling() {
|
||||
assert_evals_to!("Num.ceiling 1.1f64", 2, i64);
|
||||
fn round_f64() {
|
||||
assert_evals_to!("Num.round 1.9f64", 2, i64);
|
||||
assert_evals_to!("Num.round -1.9f64", -2, i64);
|
||||
assert_evals_to!("Num.round 0.5f64", 1, i64);
|
||||
assert_evals_to!("Num.round -0.5f64", -1, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn floor() {
|
||||
fn round_dec() {
|
||||
assert_evals_to!("Num.round 1.9dec", 2, i64);
|
||||
assert_evals_to!("Num.round -1.9dec", -2, i64);
|
||||
assert_evals_to!("Num.round 0.5dec", 1, i64);
|
||||
assert_evals_to!("Num.round -0.5dec", -1, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn ceiling_f64() {
|
||||
assert_evals_to!("Num.ceiling 1.9f64", 2, i64);
|
||||
assert_evals_to!("Num.ceiling -1.9f64", -1, i64);
|
||||
assert_evals_to!("Num.ceiling 0.5f64", 1, i64);
|
||||
assert_evals_to!("Num.ceiling -0.5f64", 0, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn ceiling_dec() {
|
||||
assert_evals_to!("Num.ceiling 1.9dec", 2, i64);
|
||||
assert_evals_to!("Num.ceiling -1.9dec", -1, i64);
|
||||
assert_evals_to!("Num.ceiling 0.5dec", 1, i64);
|
||||
assert_evals_to!("Num.ceiling -0.5dec", 0, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn floor_f64() {
|
||||
assert_evals_to!("Num.floor 1.9f64", 1, i64);
|
||||
assert_evals_to!("Num.floor -1.9f64", -2, i64);
|
||||
assert_evals_to!("Num.floor 0.5f64", 0, i64);
|
||||
assert_evals_to!("Num.floor -0.5f64", -1, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
|
||||
fn floor_dec() {
|
||||
assert_evals_to!("Num.floor 1.9dec", 1, i64);
|
||||
assert_evals_to!("Num.floor -1.9dec", -2, i64);
|
||||
assert_evals_to!("Num.floor 0.5dec", 0, i64);
|
||||
assert_evals_to!("Num.floor -0.5dec", -1, i64);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
@ -91,15 +91,11 @@ impl<T: FromWasm32Memory + Clone> FromWasm32Memory for RocList<T> {
|
||||
let capacity =
|
||||
<u32 as FromWasm32Memory>::decode(memory, offset + 4 * Builtin::WRAPPER_CAPACITY);
|
||||
|
||||
let mut items = Vec::with_capacity(length as usize);
|
||||
let step = <T as Wasm32Sized>::SIZE_OF_WASM;
|
||||
|
||||
for i in 0..length {
|
||||
let item = <T as FromWasm32Memory>::decode(
|
||||
memory,
|
||||
elements + i * <T as Wasm32Sized>::SIZE_OF_WASM as u32,
|
||||
);
|
||||
items.push(item);
|
||||
}
|
||||
let items: Vec<_> = (0..length)
|
||||
.map(|i| <T as FromWasm32Memory>::decode(memory, elements + i * step as u32))
|
||||
.collect();
|
||||
|
||||
let mut list = RocList::with_capacity(capacity as usize);
|
||||
list.extend_from_slice(&items);
|
||||
|
@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
|
||||
jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.77 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.13 : U64 = 0i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.4 (Test.27):
|
||||
let Test.39 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = TagId(0) ;
|
||||
|
@ -28,12 +28,12 @@ procedure List.90 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.
|
||||
jump List.574 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.10 (Test.69, #Attr.12):
|
||||
let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
|
@ -47,8 +47,8 @@ procedure List.9 (List.333):
|
||||
ret List.573;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Result.5 (Result.12, Result.13):
|
||||
let Result.39 : U8 = 1i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.6 : I128 = 18446744073709551616i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : U128 = 170141183460469231731687303715884105728u128;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : U64 = 9999999999999999999i64;
|
||||
|
@ -32,12 +32,12 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
|
||||
jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -30,8 +30,8 @@ procedure List.6 (#Attr.2):
|
||||
ret List.571;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : {} = Struct {};
|
||||
|
@ -25,8 +25,8 @@ procedure List.66 (#Attr.2, #Attr.3):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.2 (Test.5):
|
||||
dec Test.5;
|
||||
|
@ -250,40 +250,40 @@ procedure List.90 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
|
||||
jump List.629 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.272;
|
||||
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
let Num.287 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.286 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.288 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.294;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.296 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.296;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.291;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.285;
|
||||
let Num.295 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.295;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.261 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -193,40 +193,40 @@ procedure List.90 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_g
|
||||
jump List.595 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.262;
|
||||
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.272;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.266;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.263;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.271;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.285;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -200,40 +200,40 @@ procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_g
|
||||
jump List.595 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.262;
|
||||
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.272;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.266;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.263;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.271;
|
||||
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.285;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -122,32 +122,32 @@ procedure List.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen
|
||||
jump List.587 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.260 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.264 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.264;
|
||||
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.266;
|
||||
let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.262 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.262;
|
||||
let Num.272 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.272;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.265 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.265;
|
||||
let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -195,40 +195,40 @@ procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
|
||||
jump List.601 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.264;
|
||||
let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.265;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -198,40 +198,40 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
|
||||
jump List.613 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.264;
|
||||
let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.265;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
|
||||
joinpoint Test.7 Test.2 Test.3:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.8):
|
||||
let Test.3 : I64 = 10i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.1 (Test.9):
|
||||
let Test.4 : U8 = 10i64;
|
||||
|
@ -3,8 +3,8 @@ procedure Bool.1 ():
|
||||
ret Bool.23;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.3 (Test.4):
|
||||
ret Test.4;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.259 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
switch Test.3:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.2 (Test.3, Test.1):
|
||||
let Test.18 : Int1 = false;
|
||||
|
@ -1044,131 +1044,131 @@ procedure List.91 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
|
||||
jump List.613 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
|
||||
|
||||
procedure Num.131 (#Attr.2):
|
||||
let Num.265 : U32 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.265;
|
||||
let Num.275 : U32 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.275;
|
||||
|
||||
procedure Num.133 (#Attr.2):
|
||||
let Num.273 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.273;
|
||||
let Num.283 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.133 (#Attr.2):
|
||||
let Num.322 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.322;
|
||||
let Num.332 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.332;
|
||||
|
||||
procedure Num.133 (#Attr.2):
|
||||
let Num.337 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.337;
|
||||
let Num.347 : U64 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.347;
|
||||
|
||||
procedure Num.135 (#Attr.2):
|
||||
let Num.343 : U128 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.343;
|
||||
let Num.353 : U128 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.353;
|
||||
|
||||
procedure Num.139 (#Attr.2):
|
||||
let Num.291 : Float32 = lowlevel NumToFloatCast #Attr.2;
|
||||
ret Num.291;
|
||||
let Num.301 : Float32 = lowlevel NumToFloatCast #Attr.2;
|
||||
ret Num.301;
|
||||
|
||||
procedure Num.148 (Num.205, Num.206):
|
||||
let Num.293 : Int1 = CallByName Num.22 Num.205 Num.206;
|
||||
if Num.293 then
|
||||
ret Num.205;
|
||||
procedure Num.148 (Num.211, Num.212):
|
||||
let Num.303 : Int1 = CallByName Num.22 Num.211 Num.212;
|
||||
if Num.303 then
|
||||
ret Num.211;
|
||||
else
|
||||
ret Num.206;
|
||||
ret Num.212;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.290 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.290;
|
||||
let Num.300 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.300;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.287 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.297;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.416 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.416;
|
||||
let Num.426 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.426;
|
||||
|
||||
procedure Num.23 (#Attr.2, #Attr.3):
|
||||
let Num.409 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.409;
|
||||
let Num.419 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.419;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.271 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.271;
|
||||
let Num.281 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.412 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.412;
|
||||
let Num.422 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.422;
|
||||
|
||||
procedure Num.25 (#Attr.2, #Attr.3):
|
||||
let Num.413 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.413;
|
||||
let Num.423 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.423;
|
||||
|
||||
procedure Num.50 (#Attr.2):
|
||||
let Num.289 : U64 = lowlevel NumFloor #Attr.2;
|
||||
ret Num.289;
|
||||
let Num.299 : U64 = lowlevel NumFloor #Attr.2;
|
||||
ret Num.299;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.415 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.415;
|
||||
|
||||
procedure Num.69 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.70 (#Attr.2, #Attr.3):
|
||||
let Num.320 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
|
||||
ret Num.320;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.278 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.357 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.357;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.260 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.372 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.372;
|
||||
|
||||
procedure Num.74 (#Attr.2, #Attr.3):
|
||||
let Num.338 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
|
||||
ret Num.338;
|
||||
|
||||
procedure Num.74 (#Attr.2, #Attr.3):
|
||||
let Num.340 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
|
||||
ret Num.340;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.267 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
let Num.267 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.270 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.425 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.425;
|
||||
|
||||
procedure Num.69 (#Attr.2, #Attr.3):
|
||||
let Num.289 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
|
||||
ret Num.289;
|
||||
|
||||
procedure Num.70 (#Attr.2, #Attr.3):
|
||||
let Num.330 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
|
||||
ret Num.330;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.288 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.367 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.367;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.270 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.382 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.382;
|
||||
|
||||
procedure Num.74 (#Attr.2, #Attr.3):
|
||||
let Num.348 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
|
||||
ret Num.348;
|
||||
|
||||
procedure Num.74 (#Attr.2, #Attr.3):
|
||||
let Num.350 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
|
||||
ret Num.350;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.406 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.406;
|
||||
let Num.277 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.416 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.416;
|
||||
|
||||
procedure Num.78 (#Attr.2, #Attr.3):
|
||||
let Num.341 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
|
||||
ret Num.341;
|
||||
let Num.351 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
|
||||
ret Num.351;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.286 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.286;
|
||||
let Num.296 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.296;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.414 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.414;
|
||||
let Num.424 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.424;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -155,16 +155,16 @@ procedure List.90 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_g
|
||||
jump List.574 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.257 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.257;
|
||||
let Num.267 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -261,12 +261,12 @@ procedure List.90 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_g
|
||||
jump List.574 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -181,20 +181,20 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
|
||||
jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.257 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.257;
|
||||
let Num.267 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.258 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.258;
|
||||
let Num.268 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.268;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -158,12 +158,12 @@ procedure List.90 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_g
|
||||
jump List.574 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -165,12 +165,12 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
|
||||
jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -160,12 +160,12 @@ procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_g
|
||||
jump List.574 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -163,12 +163,12 @@ procedure List.90 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_g
|
||||
jump List.574 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
|
||||
ret List.571;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : List I64 = Array [1i64, 2i64];
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : I64 = 1i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.45 (#Attr.2):
|
||||
let Num.257 : I64 = lowlevel NumRound #Attr.2;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumRound #Attr.2;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : Decimal = 3.6dec;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : I64 = 3i64;
|
||||
|
@ -1,22 +1,22 @@
|
||||
procedure Num.157 (#Attr.2, #Attr.3):
|
||||
let Num.269 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.30 (#Attr.2):
|
||||
let Num.264 : I64 = 0i64;
|
||||
let Num.263 : Int1 = lowlevel Eq #Attr.2 Num.264;
|
||||
ret Num.263;
|
||||
let Num.274 : I64 = 0i64;
|
||||
let Num.273 : Int1 = lowlevel Eq #Attr.2 Num.274;
|
||||
ret Num.273;
|
||||
|
||||
procedure Num.39 (#Attr.2, #Attr.3):
|
||||
let Num.259 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
|
||||
procedure Num.40 (Num.227, Num.228):
|
||||
let Num.260 : Int1 = CallByName Num.30 Num.228;
|
||||
if Num.260 then
|
||||
let Num.262 : {} = Struct {};
|
||||
let Num.261 : [C {}, C I64] = TagId(0) Num.262;
|
||||
ret Num.261;
|
||||
procedure Num.40 (Num.235, Num.236):
|
||||
let Num.270 : Int1 = CallByName Num.30 Num.236;
|
||||
if Num.270 then
|
||||
let Num.272 : {} = Struct {};
|
||||
let Num.271 : [C {}, C I64] = TagId(0) Num.272;
|
||||
ret Num.271;
|
||||
else
|
||||
let Num.258 : I64 = CallByName Num.39 Num.227 Num.228;
|
||||
let Num.257 : [C {}, C I64] = TagId(1) Num.258;
|
||||
ret Num.257;
|
||||
let Num.268 : I64 = CallByName Num.157 Num.235 Num.236;
|
||||
let Num.267 : [C {}, C I64] = TagId(1) Num.268;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.8 : I64 = 1000i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.10 : I64 = 41i64;
|
||||
|
@ -44,8 +44,8 @@ procedure List.9 (List.333):
|
||||
ret List.573;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.27 (Str.86):
|
||||
let Str.249 : [C Int1, C I64] = CallByName Str.60 Str.86;
|
||||
|
@ -179,44 +179,44 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
|
||||
jump List.636 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.272;
|
||||
let Num.282 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.294;
|
||||
let Num.304 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.304;
|
||||
|
||||
procedure Num.23 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
let Num.288 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.25 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
let Num.294 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.294;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.295;
|
||||
let Num.305 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.305;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.77 (#Attr.2, #Attr.3):
|
||||
let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.291;
|
||||
let Num.301 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.301;
|
||||
|
||||
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
|
||||
|
@ -82,16 +82,16 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
|
||||
jump List.587 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0):
|
||||
joinpoint Test.26 Test.6:
|
||||
|
@ -153,44 +153,44 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
|
||||
jump List.632 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.272;
|
||||
let Num.282 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.282;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.294;
|
||||
let Num.304 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.304;
|
||||
|
||||
procedure Num.23 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
let Num.288 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.25 (#Attr.2, #Attr.3):
|
||||
let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.284;
|
||||
let Num.294 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
|
||||
ret Num.294;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.295;
|
||||
let Num.305 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.305;
|
||||
|
||||
procedure Num.71 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.72 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.77 (#Attr.2, #Attr.3):
|
||||
let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.291;
|
||||
let Num.301 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.301;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.258 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
|
||||
joinpoint Test.12 Test.2 Test.3:
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.257 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.257;
|
||||
let Num.267 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.96 (#Attr.2):
|
||||
let Num.258 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.258;
|
||||
let Num.268 : Str = lowlevel NumToStr #Attr.2;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.1 (Test.4):
|
||||
let Test.13 : [C U8, C U64] = TagId(1) Test.4;
|
||||
|
@ -1,10 +1,14 @@
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
ret Str.249;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;
|
||||
ret Test.16;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.30 : [C {}, C U64, C Str] = TagId(1) Test.5;
|
||||
ret Test.30;
|
||||
let Test.31 : [C {}, C U64, C Str] = TagId(1) Test.5;
|
||||
ret Test.31;
|
||||
|
||||
procedure Test.2 (Test.7):
|
||||
let Test.23 : [C {}, C U64, C Str] = TagId(2) Test.7;
|
||||
@ -16,13 +20,16 @@ procedure Test.6 (Test.17, #Attr.12):
|
||||
ret Test.19;
|
||||
|
||||
procedure Test.6 (Test.17, #Attr.12):
|
||||
let Test.34 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Test.33 : Str = "";
|
||||
ret Test.33;
|
||||
let Test.35 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
|
||||
let Test.34 : Str = "";
|
||||
ret Test.34;
|
||||
|
||||
procedure Test.8 (Test.24, #Attr.12):
|
||||
let Test.27 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
|
||||
ret Test.27;
|
||||
let Test.28 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
|
||||
let Test.27 : Str = "";
|
||||
let Test.26 : Str = CallByName Str.3 Test.27 Test.28;
|
||||
dec Test.28;
|
||||
ret Test.26;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.3 : U8 = 0u8;
|
||||
@ -55,7 +62,7 @@ procedure Test.0 ():
|
||||
jump Test.13 Test.21;
|
||||
|
||||
default:
|
||||
let Test.29 : U64 = 1i64;
|
||||
let Test.28 : [C {}, C U64, C Str] = CallByName Test.1 Test.29;
|
||||
jump Test.13 Test.28;
|
||||
let Test.30 : U64 = 1i64;
|
||||
let Test.29 : [C {}, C U64, C Str] = CallByName Test.1 Test.30;
|
||||
jump Test.13 Test.29;
|
||||
|
||||
|
@ -7,12 +7,12 @@ procedure Bool.2 ():
|
||||
ret Bool.24;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.0 (Test.8):
|
||||
let Test.20 : Int1 = CallByName Bool.2;
|
||||
|
@ -29,12 +29,12 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
|
||||
jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.7 (Test.11, Test.12):
|
||||
let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};
|
||||
|
@ -1,11 +1,11 @@
|
||||
procedure Num.31 (Num.199):
|
||||
let Num.258 : I64 = 2i64;
|
||||
let Num.257 : Int1 = CallByName Num.86 Num.199 Num.258;
|
||||
ret Num.257;
|
||||
procedure Num.31 (Num.205):
|
||||
let Num.268 : I64 = 2i64;
|
||||
let Num.267 : Int1 = CallByName Num.86 Num.205 Num.268;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.86 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.2 (#Derived_gen.0, #Derived_gen.1):
|
||||
let #Derived_gen.3 : [<rnu><null>, C I64 *self] = NullPointer;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.10 (Test.11):
|
||||
let Test.28 : I64 = 1i64;
|
||||
|
@ -22,12 +22,12 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
ret List.578;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.1 ():
|
||||
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
@ -21,8 +21,8 @@ procedure List.66 (#Attr.2, #Attr.3):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
@ -7,8 +7,8 @@ procedure List.6 (#Attr.2):
|
||||
ret List.572;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
|
||||
|
@ -27,8 +27,8 @@ procedure List.66 (#Attr.2, #Attr.3):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.16 (#Attr.2, #Attr.3):
|
||||
let Str.249 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
|
||||
|
@ -27,8 +27,8 @@ procedure List.66 (#Attr.2, #Attr.3):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -21,8 +21,8 @@ procedure List.5 (#Attr.2, #Attr.3):
|
||||
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.4 (Test.5, #Attr.12):
|
||||
let Test.16 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
|
@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.2 (Test.3):
|
||||
let Test.6 : U64 = 0i64;
|
||||
|
@ -8,8 +8,8 @@ procedure List.59 (List.328):
|
||||
ret List.571;
|
||||
|
||||
procedure Num.46 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.7 : I64 = 1i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.17 : {} = Struct {};
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.19 : I64 = 41i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.37 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : Decimal = 1dec;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.5 : {} = Struct {};
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.259 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.1 (Test.6):
|
||||
let Test.21 : Int1 = false;
|
||||
|
@ -1,14 +1,14 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
|
||||
joinpoint Test.12 Test.2 Test.3 Test.4:
|
||||
|
@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.28 : U64 = 0i64;
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.258 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
|
||||
let #Derived_gen.4 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.4):
|
||||
let Test.2 : I64 = StructAtIndex 0 Test.4;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.4):
|
||||
let Test.2 : I64 = 10i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.3 : I64 = StructAtIndex 0 Test.2;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.3 : I64 = 10i64;
|
||||
|
@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : List U64 = StructAtIndex 0 Test.2;
|
||||
|
@ -3,8 +3,8 @@ procedure Bool.2 ():
|
||||
ret Bool.23;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.8 : U32 = 0i64;
|
||||
|
@ -3,12 +3,12 @@ procedure Bool.11 (#Attr.2, #Attr.3):
|
||||
ret Bool.23;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
|
||||
joinpoint Test.11 Test.2 Test.3:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Str.3 (#Attr.2, #Attr.3):
|
||||
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
|
||||
|
@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
|
||||
ret List.576;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.1 (Test.2, Test.3, Test.4):
|
||||
inc 2 Test.4;
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.259 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Test.2 (Test.9, Test.10):
|
||||
let Test.38 : U8 = 1i64;
|
||||
|
@ -3,12 +3,12 @@ procedure Bool.2 ():
|
||||
ret Bool.24;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2, Test.3):
|
||||
let Test.15 : U8 = GetTagId Test.2;
|
||||
|
@ -3,12 +3,12 @@ procedure Bool.2 ():
|
||||
ret Bool.23;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.6 (Test.8, #Attr.12):
|
||||
let Test.20 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
|
||||
|
@ -1,10 +1,10 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
|
||||
joinpoint Test.7 Test.2 Test.3:
|
||||
|
@ -184,40 +184,40 @@ procedure List.90 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_g
|
||||
jump List.612 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.264;
|
||||
let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.274;
|
||||
|
||||
procedure Num.137 (#Attr.2, #Attr.3):
|
||||
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.265;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.276;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.275;
|
||||
|
||||
procedure Num.21 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.273;
|
||||
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.283;
|
||||
|
||||
procedure Num.75 (#Attr.2, #Attr.3):
|
||||
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -158,24 +158,24 @@ procedure List.90 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_g
|
||||
jump List.600 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
|
||||
|
||||
procedure Num.127 (#Attr.2):
|
||||
let Num.276 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.276;
|
||||
let Num.286 : U8 = lowlevel NumIntCast #Attr.2;
|
||||
ret Num.286;
|
||||
|
||||
procedure Num.20 (#Attr.2, #Attr.3):
|
||||
let Num.277 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.277;
|
||||
let Num.287 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
|
||||
ret Num.287;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.290;
|
||||
|
||||
procedure Num.24 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
|
||||
ret Num.288;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.279;
|
||||
let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.289;
|
||||
|
||||
procedure Str.12 (#Attr.2):
|
||||
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
|
||||
|
@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
|
||||
jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.260;
|
||||
let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.270;
|
||||
|
||||
procedure Num.51 (#Attr.2, #Attr.3):
|
||||
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.259;
|
||||
let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
|
||||
ret Num.269;
|
||||
|
||||
procedure Num.77 (#Attr.2, #Attr.3):
|
||||
let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.258;
|
||||
let Num.268 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
|
||||
ret Num.268;
|
||||
|
||||
procedure Test.3 (Test.4, Test.12):
|
||||
let Test.13 : [C U64, C U64] = TagId(0) Test.4;
|
||||
|
@ -3,8 +3,8 @@ procedure Bool.2 ():
|
||||
ret Bool.25;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
joinpoint Test.12:
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.19 : I64 = 41i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.5 : I64 = 2i64;
|
||||
|
@ -1,6 +1,6 @@
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.257;
|
||||
let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.267;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.15 : I64 = 3i64;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user