//! returns: 0
//! Ordered comparisons must canonicalize computed subword values, register
//! operands, and immediates to the representation selected for their width.

fn addU8(a: u8, b: u8) -> u8 {
    return a + b;
}

fn addU16(a: u16, b: u16) -> u16 {
    return a + b;
}

fn addU32(a: u32, b: u32) -> u32 {
    return a + b;
}

fn addI8(a: i8, b: i8) -> i8 {
    return a + b;
}

fn addI16(a: i16, b: i16) -> i16 {
    return a + b;
}

fn addI32(a: i32, b: i32) -> i32 {
    return a + b;
}

fn u8Expressions(value: u8, limit: u8) -> bool {
    return value < 0xFF and value >= 0x80 and value < limit and limit >= value;
}

fn u16Expressions(value: u16, limit: u16) -> bool {
    return value < 0xFFFF and value >= 0x8000 and value < limit and limit >= value;
}

fn u32Expressions(value: u32, limit: u32) -> bool {
    return value < 0xFFFFFFFF and value >= 0x80000000
        and value < limit and limit >= value;
}

fn i8Expressions(value: i8, limit: i8) -> bool {
    return value < 0 and value >= -128 and value < limit and limit >= value;
}

fn i16Expressions(value: i16, limit: i16) -> bool {
    return value < 0 and value >= -32768 and value < limit and limit >= value;
}

fn i32Expressions(value: i32, limit: i32) -> bool {
    return value < 0 and value >= -2147483648
        and value < limit and limit >= value;
}

fn u32Branches(value: u32, limit: u32) -> bool {
    if value >= 0xFFFFFFFF {
        return false;
    }
    if value < 0x80000000 {
        return false;
    }
    if value < limit {
        return true;
    }
    return false;
}

@default fn main() -> i32 {
    let highU8 = addU8(0x7F, 1);
    let highU16 = addU16(0x7FFF, 1);
    let highU32 = addU32(0x7FFFFFFF, 1);
    let minI8 = addI8(127, 1);
    let minI16 = addI16(32767, 1);
    let minI32 = addI32(2147483647, 1);

    assert u8Expressions(highU8, 0xFE);
    assert u16Expressions(highU16, 0xFFFE);
    assert u32Expressions(highU32, 0xFFFFFFFE);
    assert i8Expressions(minI8, -1);
    assert i16Expressions(minI16, -1);
    assert i32Expressions(minI32, -1);
    assert u32Branches(highU32, 0xFFFFFFFE);
    return 0;
}