error[E0277]: `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:62:40
   |
LL |     assert::is_transmutable::<   i8,   i16>();
   |                                        ^^^ `i8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:63:40
   |
LL |     assert::is_transmutable::<   i8,   u16>();
   |                                        ^^^ `i8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:64:40
   |
LL |     assert::is_transmutable::<   i8,   i32>();
   |                                        ^^^ `i8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:65:40
   |
LL |     assert::is_transmutable::<   i8,   f32>();
   |                                        ^^^ `i8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:66:40
   |
LL |     assert::is_transmutable::<   i8,   u32>();
   |                                        ^^^ `i8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:67:40
   |
LL |     assert::is_transmutable::<   i8,   u64>();
   |                                        ^^^ `i8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:68:40
   |
LL |     assert::is_transmutable::<   i8,   i64>();
   |                                        ^^^ `i8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:69:40
   |
LL |     assert::is_transmutable::<   i8,   f64>();
   |                                        ^^^ `i8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:70:39
   |
LL |     assert::is_transmutable::<   i8,  u128>();
   |                                       ^^^^ `i8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:71:39
   |
LL |     assert::is_transmutable::<   i8,  i128>();
   |                                       ^^^^ `i8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:73:40
   |
LL |     assert::is_transmutable::<   u8,   i16>();
   |                                        ^^^ `u8` cannot be safely transmuted into `i16` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i16`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:74:40
   |
LL |     assert::is_transmutable::<   u8,   u16>();
   |                                        ^^^ `u8` cannot be safely transmuted into `u16` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u16`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:75:40
   |
LL |     assert::is_transmutable::<   u8,   i32>();
   |                                        ^^^ `u8` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:76:40
   |
LL |     assert::is_transmutable::<   u8,   f32>();
   |                                        ^^^ `u8` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:77:40
   |
LL |     assert::is_transmutable::<   u8,   u32>();
   |                                        ^^^ `u8` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:78:40
   |
LL |     assert::is_transmutable::<   u8,   u64>();
   |                                        ^^^ `u8` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:79:40
   |
LL |     assert::is_transmutable::<   u8,   i64>();
   |                                        ^^^ `u8` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:80:40
   |
LL |     assert::is_transmutable::<   u8,   f64>();
   |                                        ^^^ `u8` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:81:39
   |
LL |     assert::is_transmutable::<   u8,  u128>();
   |                                       ^^^^ `u8` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:82:39
   |
LL |     assert::is_transmutable::<   u8,  i128>();
   |                                       ^^^^ `u8` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u8, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:84:40
   |
LL |     assert::is_transmutable::<  i16,   i32>();
   |                                        ^^^ `i16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:85:40
   |
LL |     assert::is_transmutable::<  i16,   f32>();
   |                                        ^^^ `i16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:86:40
   |
LL |     assert::is_transmutable::<  i16,   u32>();
   |                                        ^^^ `i16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:87:40
   |
LL |     assert::is_transmutable::<  i16,   u64>();
   |                                        ^^^ `i16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:88:40
   |
LL |     assert::is_transmutable::<  i16,   i64>();
   |                                        ^^^ `i16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:89:40
   |
LL |     assert::is_transmutable::<  i16,   f64>();
   |                                        ^^^ `i16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:90:39
   |
LL |     assert::is_transmutable::<  i16,  u128>();
   |                                       ^^^^ `i16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:91:39
   |
LL |     assert::is_transmutable::<  i16,  i128>();
   |                                       ^^^^ `i16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:93:40
   |
LL |     assert::is_transmutable::<  u16,   i32>();
   |                                        ^^^ `u16` cannot be safely transmuted into `i32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:94:40
   |
LL |     assert::is_transmutable::<  u16,   f32>();
   |                                        ^^^ `u16` cannot be safely transmuted into `f32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:95:40
   |
LL |     assert::is_transmutable::<  u16,   u32>();
   |                                        ^^^ `u16` cannot be safely transmuted into `u32` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u32`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:96:40
   |
LL |     assert::is_transmutable::<  u16,   u64>();
   |                                        ^^^ `u16` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:97:40
   |
LL |     assert::is_transmutable::<  u16,   i64>();
   |                                        ^^^ `u16` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:98:40
   |
LL |     assert::is_transmutable::<  u16,   f64>();
   |                                        ^^^ `u16` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:99:39
   |
LL |     assert::is_transmutable::<  u16,  u128>();
   |                                       ^^^^ `u16` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:100:39
   |
LL |     assert::is_transmutable::<  u16,  i128>();
   |                                       ^^^^ `u16` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u16, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:102:40
   |
LL |     assert::is_transmutable::<  i32,   u64>();
   |                                        ^^^ `i32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:103:40
   |
LL |     assert::is_transmutable::<  i32,   i64>();
   |                                        ^^^ `i32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:104:40
   |
LL |     assert::is_transmutable::<  i32,   f64>();
   |                                        ^^^ `i32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:105:39
   |
LL |     assert::is_transmutable::<  i32,  u128>();
   |                                       ^^^^ `i32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:106:39
   |
LL |     assert::is_transmutable::<  i32,  i128>();
   |                                       ^^^^ `i32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:108:40
   |
LL |     assert::is_transmutable::<  f32,   u64>();
   |                                        ^^^ `f32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:109:40
   |
LL |     assert::is_transmutable::<  f32,   i64>();
   |                                        ^^^ `f32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:110:40
   |
LL |     assert::is_transmutable::<  f32,   f64>();
   |                                        ^^^ `f32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:111:39
   |
LL |     assert::is_transmutable::<  f32,  u128>();
   |                                       ^^^^ `f32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:112:39
   |
LL |     assert::is_transmutable::<  f32,  i128>();
   |                                       ^^^^ `f32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:114:40
   |
LL |     assert::is_transmutable::<  u32,   u64>();
   |                                        ^^^ `u32` cannot be safely transmuted into `u64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:115:40
   |
LL |     assert::is_transmutable::<  u32,   i64>();
   |                                        ^^^ `u32` cannot be safely transmuted into `i64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:116:40
   |
LL |     assert::is_transmutable::<  u32,   f64>();
   |                                        ^^^ `u32` cannot be safely transmuted into `f64` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `f64`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:117:39
   |
LL |     assert::is_transmutable::<  u32,  u128>();
   |                                       ^^^^ `u32` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:118:39
   |
LL |     assert::is_transmutable::<  u32,  i128>();
   |                                       ^^^^ `u32` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u32, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:120:39
   |
LL |     assert::is_transmutable::<  u64,  u128>();
   |                                       ^^^^ `u64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:121:39
   |
LL |     assert::is_transmutable::<  u64,  i128>();
   |                                       ^^^^ `u64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<u64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:123:39
   |
LL |     assert::is_transmutable::<  i64,  u128>();
   |                                       ^^^^ `i64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:124:39
   |
LL |     assert::is_transmutable::<  i64,  i128>();
   |                                       ^^^^ `i64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<i64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:126:39
   |
LL |     assert::is_transmutable::<  f64,  u128>();
   |                                       ^^^^ `f64` cannot be safely transmuted into `u128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `u128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error[E0277]: `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
  --> $DIR/numbers.rs:127:39
   |
LL |     assert::is_transmutable::<  f64,  i128>();
   |                                       ^^^^ `f64` cannot be safely transmuted into `i128` in the defining scope of `assert::Context`.
   |
   = help: the trait `BikeshedIntrinsicFrom<f64, assert::Context, Assume { alignment: false, lifetimes: false, safety: false, validity: false }>` is not implemented for `i128`
note: required by a bound in `is_transmutable`
  --> $DIR/numbers.rs:12:14
   |
LL |     pub fn is_transmutable<Src, Dst>()
   |            --------------- required by a bound in this
LL |     where
LL |         Dst: BikeshedIntrinsicFrom<Src, Context>
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`

error: aborting due to 57 previous errors

For more information about this error, try `rustc --explain E0277`.