diff --git a/crates/library2/std/src/num/int/extend.fe b/crates/library2/std/src/num/int/extend.fe
index 2e052ce7c..061bc3ce2 100644
--- a/crates/library2/std/src/num/int/extend.fe
+++ b/crates/library2/std/src/num/int/extend.fe
@@ -34,7 +34,7 @@ extern {
 }
 
 pub trait Extend<Out> {
-    fn extend(self) -> Out 
+    fn extend(self) -> Out
 }
 
 impl Extend<u16> for u8 { fn extend(self) -> u16 { u8_u16_extend(self) } }
@@ -66,4 +66,4 @@ impl Extend<i128> for i32 { fn extend(self) -> i128 { i32_i128_extend(self) } }
 impl Extend<i256> for i32 { fn extend(self) -> i256 { i32_i256_extend(self) } }
 impl Extend<i128> for i64 { fn extend(self) -> i128 { i64_i128_extend(self) } }
 impl Extend<i256> for i64 { fn extend(self) -> i256 { i64_i256_extend(self) } }
-impl Extend<i256> for i128 { fn extend(self) -> i256 { i128_i256_extend(self) } }
\ No newline at end of file
+impl Extend<i256> for i128 { fn extend(self) -> i256 { i128_i256_extend(self) } }
diff --git a/crates/library2/std/src/num/int/ops/arith.fe b/crates/library2/std/src/num/int/ops/arith.fe
index 2dad574c5..02cfec1a0 100644
--- a/crates/library2/std/src/num/int/ops/arith.fe
+++ b/crates/library2/std/src/num/int/ops/arith.fe
@@ -1,159 +1,155 @@
 use ingot::ops::arith::{
-    Add, Sub, Div, Mul, Exp, 
-    Mod, Shl, Shr, Minus,
+    Add, Sub, Div, Mul, Exp,
+    Mod, Shl, Shr, Neg,
     BitAnd, BitOr, BitNot
 }
 use ingot::num::int::{usize, isize}
 
-extern {
-    fn abort() -> !
-}
-
-impl Add<Self, Self> for i8 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for i16 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for i32 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for i64 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for i128 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for i256 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u8 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u16 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u32 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u64 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u128 { fn add(self, rhs: Self) -> Self { abort() } }
-impl Add<Self, Self> for u256 { fn add(self, rhs: Self) -> Self { abort() } }
+impl Add<Self, Self> for i8 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for i16 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for i32 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for i64 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for i128 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for i256 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u8 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u16 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u32 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u64 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u128 { fn add(self, rhs: Self) -> Self { self + rhs } }
+impl Add<Self, Self> for u256 { fn add(self, rhs: Self) -> Self { self + rhs } }
 
-impl Sub<Self, Self> for i8 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for i16 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for i32 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for i64 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for i128 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for i256 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u8 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u16 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u32 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u64 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u128 { fn sub(self, rhs: Self) -> Self { abort() } }
-impl Sub<Self, Self> for u256 { fn sub(self, rhs: Self) -> Self { abort() } }
+impl Sub<Self, Self> for i8 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for i16 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for i32 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for i64 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for i128 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for i256 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u8 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u16 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u32 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u64 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u128 { fn sub(self, rhs: Self) -> Self { self - rhs } }
+impl Sub<Self, Self> for u256 { fn sub(self, rhs: Self) -> Self { self - rhs } }
 
-impl Mul<Self, Self> for i8 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for i16 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for i32 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for i64 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for i128 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for i256 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u8 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u16 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u32 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u64 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u128 { fn mul(self, rhs: Self) -> Self { abort() } }
-impl Mul<Self, Self> for u256 { fn mul(self, rhs: Self) -> Self { abort() } }
+impl Mul<Self, Self> for i8 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for i16 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for i32 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for i64 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for i128 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for i256 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u8 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u16 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u32 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u64 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u128 { fn mul(self, rhs: Self) -> Self { self * rhs } }
+impl Mul<Self, Self> for u256 { fn mul(self, rhs: Self) -> Self { self * rhs } }
 
-impl Div<Self, Self> for i8 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for i16 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for i32 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for i64 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for i128 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for i256 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u8 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u16 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u32 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u64 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u128 { fn div(self, rhs: Self) -> Self { abort() } }
-impl Div<Self, Self> for u256 { fn div(self, rhs: Self) -> Self { abort() } }
+impl Div<Self, Self> for i8 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for i16 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for i32 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for i64 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for i128 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for i256 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u8 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u16 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u32 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u64 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u128 { fn div(self, rhs: Self) -> Self { self / rhs } }
+impl Div<Self, Self> for u256 { fn div(self, rhs: Self) -> Self { self / rhs } }
 
-impl Exp<Self, Self> for i8 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for i16 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for i32 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for i64 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for i128 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for i256 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u8 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u16 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u32 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u64 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u128 { fn exp(self, rhs: Self) -> Self { abort() } }
-impl Exp<Self, Self> for u256 { fn exp(self, rhs: Self) -> Self { abort() } }
+impl Exp<Self, Self> for i8 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for i16 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for i32 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for i64 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for i128 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for i256 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u8 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u16 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u32 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u64 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u128 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
+impl Exp<Self, Self> for u256 { fn exp(self, rhs: Self) -> Self { self ** rhs } }
 
-impl Mod<Self, Self> for i8 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for i16 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for i32 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for i64 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for i128 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for i256 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u8 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u16 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u32 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u64 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u128 { fn modulo(self, rhs: Self) -> Self { abort() } }
-impl Mod<Self, Self> for u256 { fn modulo(self, rhs: Self) -> Self { abort() } }
+impl Mod<Self, Self> for i8 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for i16 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for i32 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for i64 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for i128 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for i256 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u8 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u16 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u32 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u64 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u128 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
+impl Mod<Self, Self> for u256 { fn modulo(self, rhs: Self) -> Self { self % rhs } }
 
-impl Shl<usize, Self> for i8 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for i16 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for i32 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for i64 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for i128 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for i256 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u8 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u16 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u32 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u64 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u128 { fn shl(self, rhs: usize) -> Self { abort() } }
-impl Shl<usize, Self> for u256 { fn shl(self, rhs: usize) -> Self { abort() } }
+impl Shl for i8 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for i16 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for i32 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for i64 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for i128 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for i256 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u8 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u16 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u32 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u64 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u128 { fn shl(self, rhs: Self) -> Self { self << rhs } }
+impl Shl for u256 { fn shl(self, rhs: Self) -> Self { self << rhs } }
 
-impl Shr<usize, Self> for i16 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for i32 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for i64 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for i128 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for i256 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u8 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u16 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u32 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u64 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u128 { fn shr(self, rhs: usize) -> Self { abort() } }
-impl Shr<usize, Self> for u256 { fn shr(self, rhs: usize) -> Self { abort() } }
+impl Shr for i16 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for i32 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for i64 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for i128 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for i256 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u8 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u16 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u32 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u64 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u128 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
+impl Shr for u256 { fn shr(self, rhs: Self) -> Self { self >> rhs } }
 
-impl BitAnd<Self, Self> for i8 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for i16 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for i32 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for i64 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for i128 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for i256 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u8 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u16 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u32 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u64 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u128 { fn bit_and(self, rhs: Self) -> Self { abort() } }
-impl BitAnd<Self, Self> for u256 { fn bit_and(self, rhs: Self) -> Self { abort() } }
+impl BitAnd<Self, Self> for i8 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for i16 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for i32 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for i64 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for i128 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for i256 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u8 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u16 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u32 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u64 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u128 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
+impl BitAnd<Self, Self> for u256 { fn bit_and(self, rhs: Self) -> Self { self & rhs } }
 
-impl BitOr<Self, Self> for i8 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for i16 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for i32 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for i64 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for i128 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for i256 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u8 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u16 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u32 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u64 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u128 { fn bit_or(self, rhs: Self) -> Self { abort() } }
-impl BitOr<Self, Self> for u256 { fn bit_or(self, rhs: Self) -> Self { abort() } }
+impl BitOr<Self, Self> for i8 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for i16 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for i32 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for i64 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for i128 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for i256 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u8 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u16 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u32 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u64 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u128 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
+impl BitOr<Self, Self> for u256 { fn bit_or(self, rhs: Self) -> Self { self | rhs } }
 
-impl BitNot<Self> for i8 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for i16 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for i32 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for i64 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for i128 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for i256 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u8 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u16 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u32 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u64 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u128 { fn bit_not(self) -> Self { abort() } }
-impl BitNot<Self> for u256 { fn bit_not(self) -> Self { abort() } }
+impl BitNot<Self> for i8 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for i16 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for i32 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for i64 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for i128 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for i256 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u8 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u16 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u32 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u64 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u128 { fn bit_not(self) -> Self { ~self } }
+impl BitNot<Self> for u256 { fn bit_not(self) -> Self { ~self } }
 
-impl Minus<Self> for i8 { fn minus(self) -> Self { abort() } }
-impl Minus<Self> for i16 { fn minus(self) -> Self { abort() } }
-impl Minus<Self> for i32 { fn minus(self) -> Self { abort() } }
-impl Minus<Self> for i64 { fn minus(self) -> Self { abort() } }
-impl Minus<Self> for i128 { fn minus(self) -> Self { abort() } }
-impl Minus<Self> for i256 { fn minus(self) -> Self { abort() } }
+impl Neg<Self> for i8 { fn neg(self) -> Self { -self } }
+impl Neg<Self> for i16 { fn neg(self) -> Self { -self } }
+impl Neg<Self> for i32 { fn neg(self) -> Self { -self } }
+impl Neg<Self> for i64 { fn neg(self) -> Self { -self } }
+impl Neg<Self> for i128 { fn neg(self) -> Self { -self } }
+impl Neg<Self> for i256 { fn neg(self) -> Self { -self } }
diff --git a/crates/library2/std/src/num/int/ops/cmp.fe b/crates/library2/std/src/num/int/ops/cmp.fe
index c1e04fcf3..e69de29bb 100644
--- a/crates/library2/std/src/num/int/ops/cmp.fe
+++ b/crates/library2/std/src/num/int/ops/cmp.fe
@@ -1,82 +0,0 @@
-use ingot::ops::cmp::{Eq, NotEq, Lt, LtEq, Gt, Gt, GtEq}
-
-extern {
-    fn abort() -> !
-}
-
-impl Eq<Self, Self> for i8 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for i16 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for i32 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for i64 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for i128 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for i256 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u8 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u16 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u32 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u64 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u128 { fn eq(self, rhs: Self) -> Self { abort() } }
-impl Eq<Self, Self> for u256 { fn eq(self, rhs: Self) -> Self { abort() } }
-
-impl NotEq<Self, Self> for i8 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for i16 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for i32 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for i64 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for i128 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for i256 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u8 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u16 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u32 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u64 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u128 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-impl NotEq<Self, Self> for u256 { fn not_eq(self, rhs: Self) -> Self { abort() } }
-
-impl Lt<Self, Self> for i8 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for i16 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for i32 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for i64 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for i128 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for i256 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u8 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u16 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u32 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u64 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u128 { fn lt(self, rhs: Self) -> Self { abort() } }
-impl Lt<Self, Self> for u256 { fn lt(self, rhs: Self) -> Self { abort() } }
-
-impl LtEq<Self, Self> for i8 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for i16 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for i32 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for i64 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for i128 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for i256 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u8 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u16 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u32 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u64 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u128 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-impl LtEq<Self, Self> for u256 { fn lt_eq(self, rhs: Self) -> Self { abort() } }
-
-impl Gt<Self, Self> for i8 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for i16 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for i32 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for i64 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for i128 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for i256 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u8 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u16 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u32 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u64 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u128 { fn gt(self, rhs: Self) -> Self { abort() } }
-impl Gt<Self, Self> for u256 { fn gt(self, rhs: Self) -> Self { abort() } }
-
-impl GtEq<Self, Self> for i8 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for i16 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for i32 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for i64 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for i128 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for i256 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for u8 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for u16 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for u32 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for u64 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
-impl GtEq<Self, Self> for u128 { fn gt_eq(self, rhs: Self) -> Self { abort() } }
\ No newline at end of file
diff --git a/crates/library2/std/src/ops/arith.fe b/crates/library2/std/src/ops/arith.fe
index 69d43bfdf..03c3a2073 100644
--- a/crates/library2/std/src/ops/arith.fe
+++ b/crates/library2/std/src/ops/arith.fe
@@ -29,23 +29,18 @@ pub trait Exp<RHS, Out> {
 }
 
 /// Left shift (e.g. `x << y`)
-pub trait Shl<RHS, Out> {
-    fn shl(self, rhs: RHS) -> Out
+pub trait Shl {
+    fn shl(self, rhs: Self) -> Self 
 }
 
 /// Right shift (e.g. `x >> y`)
-pub trait Shr<RHS, Out> {
-    fn shr(self, rhs: RHS) -> Out
+pub trait Shr {
+    fn shr(self, rhs: Self) -> Self 
 }
 
-/// Plus (e.g. `+x`)
-pub trait Plus<Out> {
-    fn plus(self) -> Out
-}
-
-/// Minus (e.g. `-x`)
-pub trait Minus<Out> {
-    fn minus(self) -> Out
+/// Neg (e.g. `-x`)
+pub trait Neg<Out> {
+    fn neg(self) -> Out
 }
 
 /// Bitwise and (e.g. `x && y`)
@@ -61,4 +56,4 @@ pub trait BitOr<RHS, Out> {
 /// Bitwise not (e.g. `~x`)
 pub trait BitNot<Out> {
     fn bit_not(self) -> Out
-}
\ No newline at end of file
+}
diff --git a/crates/library2/std/src/ops/logical.fe b/crates/library2/std/src/ops/logical.fe
deleted file mode 100644
index 67d04f508..000000000
--- a/crates/library2/std/src/ops/logical.fe
+++ /dev/null
@@ -1,30 +0,0 @@
-extern {
-    fn abort() -> !
-}
-
-/// Logical and (e.g. `x && y`)
-pub trait And<RHS, Out> {
-    fn and(self, rhs: RHS) -> Out
-}
-
-/// Logical or (e.g. `x || y`)
-pub trait Or<RHS, Out> {
-    fn or(self, rhs: RHS) -> Out
-}
-
-/// Logical not (e.g. `!x`)
-pub trait Not<Out> {
-    fn not(self) -> Out
-}
-
-impl And<Self, Self> for bool {
-    fn and(self, rhs: Self) -> Self { abort() }
-}
-
-impl Or<Self, Self> for bool {
-    fn or(self, rhs: Self) -> Self { abort() }
-}
-
-impl Not<Self> for bool {
-    fn not(self) -> Self { abort() }
-}
\ No newline at end of file