From e3c8c99583e96466b00fa51514763eb3b84add6a Mon Sep 17 00:00:00 2001
From: Nikolay Volf <nikvolf@gmail.com>
Date: Sat, 27 Feb 2016 15:02:02 +0300
Subject: [PATCH] finally caught mul bug

---
 util/src/uint.rs | 104 +++++++++++++++++++++++++++++------------------
 1 file changed, 65 insertions(+), 39 deletions(-)

diff --git a/util/src/uint.rs b/util/src/uint.rs
index b4940cfb8..97e7eecb3 100644
--- a/util/src/uint.rs
+++ b/util/src/uint.rs
@@ -173,53 +173,60 @@ macro_rules! uint_overflowing_mul {
 				mov %rax, $0
 				mov %rdx, $1
 
-				mov $6, %rax
-				mulq $9
+				mov $5, %rax
+				mulq $10
 				add %rax, $1
+				adc $$0, %rdx
 				mov %rdx, $2
 
 				mov $5, %rax
-				mulq $10
-				add %rax, $1
-				adc %rdx, $2
-
-				mov $6, %rax
-				mulq $10
+				mulq $11
 				add %rax, $2
+				adc $$0, %rdx
 				mov %rdx, $3
 
-				mov $7, %rax
-				mulq $9
-				add %rax, $2
-				adc %rdx, $3
-
-				mov $5, %rax
-				mulq $11
-    			add %rax, $2
-				adc %rdx, $3
-
-				mov $8, %rax
-				mulq $9
-				adc %rax, $3
-				adc $$0, %rdx
-				mov %rdx, %rcx
-
-				mov $7, %rax
-				mulq $10
-				add %rax, $3
-				adc $$0, %rdx
-				or %rdx, %rcx
-
-				mov $6, %rax
-				mulq $11
-				add %rax, $3
-				adc $$0, %rdx
-				or %rdx, %rcx
-
 				mov $5, %rax
 				mulq $12
 				add %rax, $3
 				adc $$0, %rdx
+				mov %rdx, %rcx
+
+				mov $6, %rax
+				mulq $9
+				add %rax, $1
+				adc %rdx, $2
+				adc $$0, $3
+				adc $$0, %rcx
+
+				mov $6, %rax
+				mulq $10
+				add %rax, $2
+				adc %rdx, $3
+				adc $$0, %rcx
+				adc $$0, $3
+				adc $$0, %rcx
+
+				mov $6, %rax
+				mulq $11
+				add %rax, $3
+				adc $$0, %rdx
+				or %rdx, %rcx
+
+				mov $7, %rax
+				mulq $9
+				add %rax, $2
+				adc %rdx, $3
+				adc $$0, %rcx
+
+				mov $7, %rax
+				mulq $10
+				add %rax, $3
+				adc $$0, %rdx
+				or %rdx, %rcx
+
+				mov $8, %rax
+				mulq $9
+				add %rax, $3
 				or %rdx, %rcx
 
 				cmpq $$0, %rcx
@@ -251,15 +258,15 @@ macro_rules! uint_overflowing_mul {
 				jrcxz 2f
 				popcnt $7, %rcx
 
-			    2:
-			    "
+				2:
+				"
 				: /* $0 */ "={r8}"(result[0]), /* $1 */ "={r9}"(result[1]), /* $2 */ "={r10}"(result[2]),
 				  /* $3 */ "={r11}"(result[3]), /* $4 */  "={rcx}"(overflow)
 
 				: /* $5 */ "m"(self_t[0]), /* $6 */ "m"(self_t[1]), /* $7 */  "m"(self_t[2]),
 				  /* $8 */ "m"(self_t[3]), /* $9 */ "m"(other_t[0]), /* $10 */ "m"(other_t[1]),
 				  /* $11 */ "m"(other_t[2]), /* $12 */ "m"(other_t[3])
-           		: "rax", "rdx", "rbx"
+           		: "rax", "rdx"
 				:
 
 			);
@@ -1533,6 +1540,8 @@ mod tests {
 
 	#[test]
 	fn u256_multi_muls() {
+		use hash::*;
+
         let (result, _) = U256([0, 0, 0, 0]).overflowing_mul(U256([0, 0, 0, 0]));
         assert_eq!(U256([0, 0, 0, 0]), result);
 
@@ -1572,6 +1581,23 @@ mod tests {
         let (result, _) = U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX])
 			.overflowing_mul(U256([::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX, ::std::u64::MAX]));
         assert_eq!(U256([1, 0, 0, 0]), result);
+
+		let x1 = U256::from_str("0000000000000000000000000000000000000000000000000000012365124623").unwrap();
+		let x2sqr_right = U256::from_str("000000000000000000000000000000000000000000014baeef72e0378e2328c9").unwrap();
+		let x1sqr = x1 * x1;
+		assert_eq!(H256::from(x2sqr_right), H256::from(x1sqr));
+		let x1cube = x1sqr * x1;
+		let x1cube_right = U256::from_str("0000000000000000000000000000000001798acde139361466f712813717897b").unwrap();
+		assert_eq!(H256::from(x1cube_right), H256::from(x1cube));
+		let x1quad = x1cube * x1;
+		let x1quad_right = U256::from_str("000000000000000000000001adbdd6bd6ff027485484b97f8a6a4c7129756dd1").unwrap();
+		assert_eq!(H256::from(x1quad_right), H256::from(x1quad));
+		let x1penta = x1quad * x1;
+		let x1penta_right = U256::from_str("00000000000001e92875ac24be246e1c57e0507e8c46cc8d233b77f6f4c72993").unwrap();
+		assert_eq!(H256::from(x1penta_right), H256::from(x1penta));
+		let x1septima = x1penta * x1;
+		let x1septima_right = U256::from_str("00022cca1da3f6e5722b7d3cc5bbfb486465ebc5a708dd293042f932d7eee119").unwrap();
+		assert_eq!(H256::from(x1septima_right), H256::from(x1septima));
 	}
 
     #[test]