define other signed machine integers

base/I128.kind

@@ -0,0 +1,3 @@
+type I128 {
+  new(value: Word(128))
+}

base/I128/abs.kind

@@ -0,0 +1,3 @@
+I128.abs(a: I128): I128
+  open a
+  I128.new(Word.abs!(a.value))

base/I128/add.kind

@@ -0,0 +1,4 @@
+I128.add(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.add!(a.value, b.value))

base/I128/and.kind

@@ -0,0 +1,4 @@
+I128.and(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.and!(a.value, b.value))

base/I128/bit_length.kind

@@ -0,0 +1,3 @@
+I128.bit_length(size: I128): Nat
+  open size
+  Word.bit_length!(size.value)

base/I128/cmp.kind

@@ -0,0 +1,4 @@
+I128.cmp(a: I128, b: I128): Cmp
+  open a
+  open b
+  Word.s_cmp!(a.value, b.value)

base/I128/div.kind

@@ -0,0 +1,4 @@
+I128.div(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.div!(a.value, b.value))

base/I128/eql.kind

@@ -0,0 +1,4 @@
+I128.eql(a: I128, b: I128): Bool
+  open a
+  open b
+  Word.eql!(a.value, b.value)

base/I128/for.kind

@@ -0,0 +1,5 @@
+I128.for<S: Type>(state: S, from: I128, til: I128, func: I128 -> S -> S): S
+  case I128.eql(from,til) {
+    true: state
+    false: I128.for<S>(func(from,state), I128.inc(from), til, func)
+  }

base/I128/gte.kind

@@ -0,0 +1,2 @@
+I128.gte(a: I128, b: I128): Bool
+  Cmp.as_gte(I128.cmp(a, b))

base/I128/gtn.kind

@@ -0,0 +1,2 @@
+I128.gtn(a: I128, b: I128): Bool
+  Cmp.as_gtn(I128.cmp(a, b))

base/I128/inc.kind

@@ -0,0 +1,3 @@
+I128.inc(a: I128): I128
+  open a
+  I128.new(Word.inc!(a.value))

base/I128/is_neg.kind

@@ -0,0 +1,3 @@
+I128.is_neg(a: I128): Bool
+  open a
+  Word.is_neg!(a.value, false)

base/I128/length.kind

@@ -0,0 +1,3 @@
+I128.length(str: String): I128
+  I128.length(str)
+

base/I128/lte.kind

@@ -0,0 +1,2 @@
+I128.lte(a: I128, b: I128): Bool
+  Cmp.as_lte(I128.cmp(a, b))

base/I128/ltn.kind

@@ -0,0 +1,2 @@
+I128.ltn(a: I128, b: I128): Bool
+  Cmp.as_ltn(I128.cmp(a, b))

base/I128/mod.kind

@@ -0,0 +1,4 @@
+I128.mod(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.mod!(a.value, b.value))

base/I128/mul.kind

@@ -0,0 +1,5 @@
+I128.mul(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.mul!(a.value, b.value))
+

base/I128/neg.kind

@@ -0,0 +1,3 @@
+I128.neg(a: I128): I128
+  open a
+  I128.new(Word.neg!(a.value))

base/I128/or.kind

@@ -0,0 +1,5 @@
+I128.or(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.or!(a.value, b.value))
+

base/I128/pow.kind

@@ -0,0 +1,4 @@
+I128.pow(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.pow!(a.value, b.value))

base/I128/shl.kind

@@ -0,0 +1,4 @@
+I128.shl(n: I128, a: I128): I128
+  open n
+  open a
+  I128.new(Word.s_shl!(n.value, a.value))

base/I128/show.kind

@@ -0,0 +1,3 @@
+I128.show(a: I128): String
+  open a
+  Word.show!(a.value)

base/I128/shr.kind

@@ -0,0 +1,4 @@
+I128.shr(n: I128, a: I128): I128
+  open n
+  open a
+  I128.new(Word.s_shr!(n.value, a.value))

base/I128/slice.kind

@@ -0,0 +1,4 @@
+I128.slice(i: I128, j: I128, str: String): String
+  open i
+  open j
+  Word.s_slice!(i.value, j.value, str)

base/I128/sqrt.kind

@@ -0,0 +1,3 @@
+I128.sqrt(val: I128): I128
+  open val
+  I128.new(Word.s_sqrt!(val.value))

base/I128/sub.kind

@@ -0,0 +1,4 @@
+I128.sub(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.sub!(a.value, b.value))

base/I128/to_bits.kind

@@ -0,0 +1,3 @@
+I128.to_bits(a: I128): Bits
+  open a
+  Word.to_bits!(a.value)

base/I128/to_f64.kind

@@ -0,0 +1,3 @@
+I128.to_f64(a: I128): F64
+  open a
+  Word.s_to_f64!(a.value)

base/I128/to_int.kind

@@ -0,0 +1,3 @@
+I128.to_int(a: I128): Int
+  open a
+  Word.to_int!(a.value)

base/I128/to_string.kind

@@ -0,0 +1,3 @@
+I128.show(a: I128): String
+  open a
+  Word.s_show!(a.value)

base/I128/xor.kind

@@ -0,0 +1,4 @@
+I128.xor(a: I128, b: I128): I128
+  open a
+  open b
+  I128.new(Word.xor!(a.value, b.value))

base/I128/zero.kind

@@ -0,0 +1,2 @@
+I128.zero: I128
+  I128.new(Word.zero!)

base/I16.kind

@@ -0,0 +1,3 @@
+type I16 {
+  new(value: Word(16))
+}

base/I16/abs.kind

@@ -0,0 +1,3 @@
+I16.abs(a: I16): I16
+  open a
+  I16.new(Word.abs!(a.value))

base/I16/add.kind

@@ -0,0 +1,4 @@
+I16.add(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.add!(a.value, b.value))

base/I16/and.kind

@@ -0,0 +1,4 @@
+I16.and(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.and!(a.value, b.value))

base/I16/bit_length.kind

@@ -0,0 +1,3 @@
+I16.bit_length(size: I16): Nat
+  open size
+  Word.bit_length!(size.value)

base/I16/cmp.kind

@@ -0,0 +1,4 @@
+I16.cmp(a: I16, b: I16): Cmp
+  open a
+  open b
+  Word.s_cmp!(a.value, b.value)

base/I16/div.kind

@@ -0,0 +1,4 @@
+I16.div(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.div!(a.value, b.value))

base/I16/eql.kind

@@ -0,0 +1,4 @@
+I16.eql(a: I16, b: I16): Bool
+  open a
+  open b
+  Word.eql!(a.value, b.value)

base/I16/for.kind

@@ -0,0 +1,5 @@
+I16.for<S: Type>(state: S, from: I16, til: I16, func: I16 -> S -> S): S
+  case I16.eql(from,til) {
+    true: state
+    false: I16.for<S>(func(from,state), I16.inc(from), til, func)
+  }

base/I16/gte.kind

@@ -0,0 +1,2 @@
+I16.gte(a: I16, b: I16): Bool
+  Cmp.as_gte(I16.cmp(a, b))

base/I16/gtn.kind

@@ -0,0 +1,2 @@
+I16.gtn(a: I16, b: I16): Bool
+  Cmp.as_gtn(I16.cmp(a, b))

base/I16/inc.kind

@@ -0,0 +1,3 @@
+I16.inc(a: I16): I16
+  open a
+  I16.new(Word.inc!(a.value))

base/I16/is_neg.kind

@@ -0,0 +1,3 @@
+I16.is_neg(a: I16): Bool
+  open a
+  Word.is_neg!(a.value, false)

base/I16/length.kind

@@ -0,0 +1,3 @@
+I16.length(str: String): I16
+  I16.length(str)
+

base/I16/lte.kind

@@ -0,0 +1,2 @@
+I16.lte(a: I16, b: I16): Bool
+  Cmp.as_lte(I16.cmp(a, b))

base/I16/ltn.kind

@@ -0,0 +1,2 @@
+I16.ltn(a: I16, b: I16): Bool
+  Cmp.as_ltn(I16.cmp(a, b))

base/I16/mod.kind

@@ -0,0 +1,4 @@
+I16.mod(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.mod!(a.value, b.value))

base/I16/mul.kind

@@ -0,0 +1,5 @@
+I16.mul(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.mul!(a.value, b.value))
+

base/I16/neg.kind

@@ -0,0 +1,3 @@
+I16.neg(a: I16): I16
+  open a
+  I16.new(Word.neg!(a.value))

base/I16/or.kind

@@ -0,0 +1,5 @@
+I16.or(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.or!(a.value, b.value))
+

base/I16/pow.kind

@@ -0,0 +1,4 @@
+I16.pow(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.pow!(a.value, b.value))

base/I16/shl.kind

@@ -0,0 +1,4 @@
+I16.shl(n: I16, a: I16): I16
+  open n
+  open a
+  I16.new(Word.s_shl!(n.value, a.value))

base/I16/show.kind

@@ -0,0 +1,3 @@
+I16.show(a: I16): String
+  open a
+  Word.show!(a.value)

base/I16/shr.kind

@@ -0,0 +1,4 @@
+I16.shr(n: I16, a: I16): I16
+  open n
+  open a
+  I16.new(Word.s_shr!(n.value, a.value))

base/I16/slice.kind

@@ -0,0 +1,4 @@
+I16.slice(i: I16, j: I16, str: String): String
+  open i
+  open j
+  Word.s_slice!(i.value, j.value, str)

base/I16/sqrt.kind

@@ -0,0 +1,3 @@
+I16.sqrt(val: I16): I16
+  open val
+  I16.new(Word.s_sqrt!(val.value))

base/I16/sub.kind

@@ -0,0 +1,4 @@
+I16.sub(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.sub!(a.value, b.value))

base/I16/to_bits.kind

@@ -0,0 +1,3 @@
+I16.to_bits(a: I16): Bits
+  open a
+  Word.to_bits!(a.value)

base/I16/to_f64.kind

@@ -0,0 +1,3 @@
+I16.to_f64(a: I16): F64
+  open a
+  Word.s_to_f64!(a.value)

base/I16/to_int.kind

@@ -0,0 +1,3 @@
+I16.to_int(a: I16): Int
+  open a
+  Word.to_int!(a.value)

base/I16/to_string.kind

@@ -0,0 +1,3 @@
+I16.show(a: I16): String
+  open a
+  Word.s_show!(a.value)

base/I16/xor.kind

@@ -0,0 +1,4 @@
+I16.xor(a: I16, b: I16): I16
+  open a
+  open b
+  I16.new(Word.xor!(a.value, b.value))

base/I16/zero.kind

@@ -0,0 +1,2 @@
+I16.zero: I16
+  I16.new(Word.zero!)

base/I256.kind

@@ -0,0 +1,3 @@
+type I256 {
+  new(value: Word(256))
+}

base/I256/abs.kind

@@ -0,0 +1,3 @@
+I256.abs(a: I256): I256
+  open a
+  I256.new(Word.abs!(a.value))

base/I256/add.kind

@@ -0,0 +1,4 @@
+I256.add(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.add!(a.value, b.value))

base/I256/and.kind

@@ -0,0 +1,4 @@
+I256.and(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.and!(a.value, b.value))

base/I256/bit_length.kind

@@ -0,0 +1,3 @@
+I256.bit_length(size: I256): Nat
+  open size
+  Word.bit_length!(size.value)

base/I256/cmp.kind

@@ -0,0 +1,4 @@
+I256.cmp(a: I256, b: I256): Cmp
+  open a
+  open b
+  Word.s_cmp!(a.value, b.value)

base/I256/div.kind

@@ -0,0 +1,4 @@
+I256.div(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.div!(a.value, b.value))

base/I256/eql.kind

@@ -0,0 +1,4 @@
+I256.eql(a: I256, b: I256): Bool
+  open a
+  open b
+  Word.eql!(a.value, b.value)

base/I256/for.kind

@@ -0,0 +1,5 @@
+I256.for<S: Type>(state: S, from: I256, til: I256, func: I256 -> S -> S): S
+  case I256.eql(from,til) {
+    true: state
+    false: I256.for<S>(func(from,state), I256.inc(from), til, func)
+  }

base/I256/gte.kind

@@ -0,0 +1,2 @@
+I256.gte(a: I256, b: I256): Bool
+  Cmp.as_gte(I256.cmp(a, b))

base/I256/gtn.kind

@@ -0,0 +1,2 @@
+I256.gtn(a: I256, b: I256): Bool
+  Cmp.as_gtn(I256.cmp(a, b))

base/I256/inc.kind

@@ -0,0 +1,3 @@
+I256.inc(a: I256): I256
+  open a
+  I256.new(Word.inc!(a.value))

base/I256/is_neg.kind

@@ -0,0 +1,3 @@
+I256.is_neg(a: I256): Bool
+  open a
+  Word.is_neg!(a.value, false)

base/I256/length.kind

@@ -0,0 +1,3 @@
+I256.length(str: String): I256
+  I256.length(str)
+

base/I256/lte.kind

@@ -0,0 +1,2 @@
+I256.lte(a: I256, b: I256): Bool
+  Cmp.as_lte(I256.cmp(a, b))

base/I256/ltn.kind

@@ -0,0 +1,2 @@
+I256.ltn(a: I256, b: I256): Bool
+  Cmp.as_ltn(I256.cmp(a, b))

base/I256/mod.kind

@@ -0,0 +1,4 @@
+I256.mod(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.mod!(a.value, b.value))

base/I256/mul.kind

@@ -0,0 +1,5 @@
+I256.mul(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.mul!(a.value, b.value))
+

base/I256/neg.kind

@@ -0,0 +1,3 @@
+I256.neg(a: I256): I256
+  open a
+  I256.new(Word.neg!(a.value))

base/I256/or.kind

@@ -0,0 +1,5 @@
+I256.or(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.or!(a.value, b.value))
+

base/I256/pow.kind

@@ -0,0 +1,4 @@
+I256.pow(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.pow!(a.value, b.value))

base/I256/shl.kind

@@ -0,0 +1,4 @@
+I256.shl(n: I256, a: I256): I256
+  open n
+  open a
+  I256.new(Word.s_shl!(n.value, a.value))

base/I256/show.kind

@@ -0,0 +1,3 @@
+I256.show(a: I256): String
+  open a
+  Word.show!(a.value)

base/I256/shr.kind

@@ -0,0 +1,4 @@
+I256.shr(n: I256, a: I256): I256
+  open n
+  open a
+  I256.new(Word.s_shr!(n.value, a.value))

base/I256/slice.kind

@@ -0,0 +1,4 @@
+I256.slice(i: I256, j: I256, str: String): String
+  open i
+  open j
+  Word.s_slice!(i.value, j.value, str)

base/I256/sqrt.kind

@@ -0,0 +1,3 @@
+I256.sqrt(val: I256): I256
+  open val
+  I256.new(Word.s_sqrt!(val.value))

base/I256/sub.kind

@@ -0,0 +1,4 @@
+I256.sub(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.sub!(a.value, b.value))

base/I256/to_bits.kind

@@ -0,0 +1,3 @@
+I256.to_bits(a: I256): Bits
+  open a
+  Word.to_bits!(a.value)

base/I256/to_f64.kind

@@ -0,0 +1,3 @@
+I256.to_f64(a: I256): F64
+  open a
+  Word.s_to_f64!(a.value)

base/I256/to_int.kind

@@ -0,0 +1,3 @@
+I256.to_int(a: I256): Int
+  open a
+  Word.to_int!(a.value)

base/I256/to_string.kind

@@ -0,0 +1,3 @@
+I256.show(a: I256): String
+  open a
+  Word.s_show!(a.value)

base/I256/xor.kind

@@ -0,0 +1,4 @@
+I256.xor(a: I256, b: I256): I256
+  open a
+  open b
+  I256.new(Word.xor!(a.value, b.value))

base/I256/zero.kind

@@ -0,0 +1,2 @@
+I256.zero: I256
+  I256.new(Word.zero!)

base/I64.kind

@@ -0,0 +1,3 @@
+type I64 {
+  new(value: Word(64))
+}