diff --git a/include/data/encoding/halves.hpp b/include/data/encoding/halves.hpp
index 86411bea..551d620a 100644
--- a/include/data/encoding/halves.hpp
+++ b/include/data/encoding/halves.hpp
@@ -184,7 +184,7 @@ namespace data::encoding {
     
     template <typename half>
     typename twice<half>::type inline subtract(half a, half b, half r) {
-        return (typename twice<half>::type)(a) - b + r;
+        return r + a - b;
     };
     
     template <typename half>
diff --git a/include/data/encoding/words.hpp b/include/data/encoding/words.hpp
index c0986f0b..3dfd2e28 100644
--- a/include/data/encoding/words.hpp
+++ b/include/data/encoding/words.hpp
@@ -14,8 +14,6 @@
 
 namespace data::arithmetic {
     
-    // Note: some of the type and var names in the following functions
-    // are very confusing. It would be good to fix them. 
     template <typename sen, typename it>
     requires std::input_iterator<it> && std::sentinel_for<sen, it>
     bool equal(sen z, it i, it j) {
@@ -61,9 +59,9 @@ namespace data::arithmetic {
         return std::weak_ordering::equivalent;
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    void bit_negate(sen z, ita i, itb j) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    void bit_negate(sen z, ito i, iti j) {
         while (i != z) {
             *i = ~ *j;
             i++;
@@ -71,9 +69,9 @@ namespace data::arithmetic {
         }
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    void bit_and(sen z, ita i, itb a, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    void bit_and(sen z, ito i, iti a, iti b) {
         while (i != z) {
             *i = *a & *b;
             i++;
@@ -82,9 +80,9 @@ namespace data::arithmetic {
         }
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    void bit_or(sen z, ita i, itb a, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    void bit_or(sen z, ito i, iti a, iti b) {
         while (i != z) {
             *i = *a | *b;
             i++;
@@ -93,9 +91,9 @@ namespace data::arithmetic {
         }
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    void bit_xor(sen z, ita i, itb a, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    void bit_xor(sen z, ito i, iti a, iti b) {
         while (i != z) {
             *i = *a ^ *b;
             i++;
@@ -104,9 +102,9 @@ namespace data::arithmetic {
         }
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    digit plus(sen z, ita a, digit d, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    digit plus(sen z, ito a, digit d, iti b) {
         using two_digits = typename encoding::twice<digit>::type;
         
         digit remainder = d;
@@ -122,9 +120,9 @@ namespace data::arithmetic {
         return remainder;
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    digit minus(sen z, ita a, digit d, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    digit minus(sen z, ito a, digit d, iti b) {
         digit remainder = d;
         while (a != z) {
             if (*b >= remainder) {
@@ -141,9 +139,9 @@ namespace data::arithmetic {
         return remainder;
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    digit plus(sen z, ita i, itb a, itb b) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    digit plus(sen z, ito i, iti a, iti b) {
         using two_digits = typename encoding::twice<digit>::type;
         
         digit remainder = 0;
@@ -160,13 +158,14 @@ namespace data::arithmetic {
         return remainder;
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    digit minus(sen z, ita a, itb b, itb i) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    digit minus(sen z, ito i, iti a, iti b) {
         using two_digits = typename encoding::twice<digit>::type;
         
-        digit remainder = 0;
+        two_digits remainder = 0;
         
+        int dig = 0;
         while (i != z) {
             two_digits result = encoding::subtract<digit>(*a, *b, remainder);
             remainder = encoding::greater_half(result);
@@ -174,14 +173,15 @@ namespace data::arithmetic {
             i++;
             a++;
             b++;
+            dig ++;
         }
         
         return remainder;
     }
     
-    template <typename digit, typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, digit> && std::sentinel_for<sen, ita>
-    digit times(sen z, ita a, itb b, itb i) {
+    template <typename digit, typename sen, typename ito, typename iti>
+    requires std::sentinel_for<sen, ito> && std::output_iterator<ito, digit> && std::input_iterator<iti> 
+    digit times(sen z, ito i, iti a, iti b) {
         using two_digits = typename encoding::twice<digit>::type;
         
         digit remainder = 0;
@@ -232,7 +232,7 @@ namespace data::arithmetic {
     
     // you have to use reverse iterators for this function. 
     template <typename sen, typename ita, typename itb>
-    requires std::input_iterator<itb> && std::output_iterator<ita, byte> && std::sentinel_for<sen, ita>
+    requires std::input_iterator<itb> && std::output_iterator<ita, byte> && std::sentinel_for<sen, itb>
     void shift_right(ita &i, sen z, itb b, byte amount, byte fill) {
         using two_digits = typename encoding::twice<byte>::type;
         
diff --git a/include/data/math/number/bounded/bounded.hpp b/include/data/math/number/bounded/bounded.hpp
index 3c7493a7..670b5975 100644
--- a/include/data/math/number/bounded/bounded.hpp
+++ b/include/data/math/number/bounded/bounded.hpp
@@ -13,6 +13,7 @@
 #include <data/encoding/halves.hpp>
 #include <data/math/number/bytes/N.hpp>
 #include <data/encoding/words.hpp>
+#include <data/io/wait_for_enter.hpp>
 
 namespace data::math::number {
     
@@ -476,21 +477,21 @@ namespace data::math::number {
     sint<r, size> operator+(const sint<r, size> &a, const uint<r, size> &b) {
         sint<r, size> x;
         std::copy(b.begin(), b.end(), x.begin());
-        return a + b;
+        return a + x;
     }
     
     template <endian::order r, size_t size>
     sint<r, size> operator-(const sint<r, size> &a, const uint<r, size> &b) {
         sint<r, size> x;
         std::copy(b.begin(), b.end(), x.begin());
-        return a - b;
+        return a - x;
     }
     
     template <endian::order r, size_t size>
     sint<r, size> operator*(const sint<r, size> &a, const uint<r, size> &b) {
         sint<r, size> x;
         std::copy(b.begin(), b.end(), x.begin());
-        return a * b;
+        return a * x;
     }
 
 }
@@ -781,16 +782,24 @@ namespace data::math::number {
     }
     
     template <bool u, endian::order o, size_t size>
-    bounded<u, o, size> inline operator-(const bounded<u, o, size> &a, const bounded<u, o, size> &n) {
+    bounded<u, o, size> operator-(const bounded<u, o, size> &a, const bounded<u, o, size> &n) {
+        bounded<u, o, size> z;
+        std::copy(n.begin(), n.end(), z.begin());
+        z.bit_negate();
+        ++z;
         bounded<u, o, size> x;
-        data::arithmetic::minus<byte>(x.words().end(), x.words().begin(), a.words().begin(), n.words().begin());
+        data::arithmetic::minus<byte>(x.words().end(), x.words().begin(), a.words().begin(), z.words().begin());
         return x;
     }
     
     template <bool u, endian::order o, size_t size>
-    bounded<u, o, size> inline &operator-=(bounded<u, o, size> &a, const bounded<u, o, size> &n) {
-        data::arithmetic::minus<byte>(a.words().end(), a.words().begin(), 
-            const_cast<const bounded<u, o, size>&>(a).words().begin(), n.words().begin());
+    bounded<u, o, size> &operator-=(bounded<u, o, size> &a, const bounded<u, o, size> &n) {
+        bounded<u, o, size> z;
+        std::copy(n.begin(), n.end(), z.begin());
+        z.bit_negate();
+        ++z;
+        data::arithmetic::plus<byte>(a.words().end(), a.words().begin(), 
+            const_cast<const bounded<u, o, size>&>(a).words().begin(), z.words().begin());
         return a;
     }
     
diff --git a/test/testExtendedEuclidian.cpp b/test/testExtendedEuclidian.cpp
index a2669f20..d44148a5 100644
--- a/test/testExtendedEuclidian.cpp
+++ b/test/testExtendedEuclidian.cpp
@@ -32,11 +32,11 @@ namespace data {
         test_extended_euclidian<int64, int64> {};
         test_extended_euclidian<Z, N>{};
         test_extended_euclidian<Zl1, Nl>{};
-        test_extended_euclidian<Zb1, Nb>{};/*
+        test_extended_euclidian<Zb1, Nb>{};
         test_extended_euclidian<int_big<9>, uint_big<9>>{};
         test_extended_euclidian<int_big<10>, uint_big<10>>{};
         test_extended_euclidian<int_big<11>, uint_big<11>>{};
-        test_extended_euclidian<int_big<20>, uint_big<20>>{};*/
+        test_extended_euclidian<int_big<20>, uint_big<20>>{};
         
     }