diff --git a/hadamard_decoder.hh b/hadamard_decoder.hh
index 921338d..3cad762 100644
--- a/hadamard_decoder.hh
+++ b/hadamard_decoder.hh
@@ -11,7 +11,6 @@ namespace CODE {
 template <int K>
 class HadamardDecoder
 {
-	static const int W = 1 << K;
 	static const int N = 1 << (K - 1);
 public:
 	int operator()(const int8_t *c)
@@ -50,35 +49,19 @@ public:
 };
 
 template <>
-class HadamardDecoder<2>
+struct HadamardDecoder<2>
 {
-	static const int K = 2;
-	static const int W = 1 << K;
-public:
 	int operator()(const int8_t *code)
 	{
-		int tmp[2] = {
-			code[0] + code[1], code[0] - code[1],
-		};
-		int sum[W] = {
-			+ tmp[0],
-			+ tmp[1],
-			- tmp[0],
-			- tmp[1],
-		};
-		int word = 0, best = 0, next = 0;
-		for (int msg = 0 ; msg < W; ++msg) {
-			if (sum[msg] > best) {
-				next = best;
-				best = sum[msg];
-				word = msg;
-			} else if (sum[msg] > next) {
-				next = sum[msg];
-			}
-		}
-		if (best == next)
+		int x = code[0] + code[1];
+		int y = code[0] - code[1];
+		int mx = std::abs(x);
+		int my = std::abs(y);
+		if (mx == my)
 			return -1;
-		return word;
+		if (mx > my)
+			return 2 * (x < 0);
+		return 1 + 2 * (y < 0);
 	}
 };
 
@@ -86,7 +69,7 @@ template <>
 class HadamardDecoder<3>
 {
 	static const int K = 3;
-	static const int W = 1 << K;
+	static const int N = 1 << (K - 1);
 public:
 	int operator()(const int8_t *c)
 	{
@@ -94,28 +77,22 @@ public:
 			c[0] + c[1], c[0] - c[1],
 			c[2] + c[3], c[2] - c[3],
 		};
-		int e[4] = {
-			d[0] + d[2], d[0] - d[2],
-			d[1] + d[3], d[1] - d[3],
-		};
-		int sum[W] = {
-			+ e[0],
-			+ e[2],
-			+ e[1],
-			+ e[3],
-			- e[0],
-			- e[2],
-			- e[1],
-			- e[3],
+		int sum[4] = {
+			d[0] + d[2],
+			d[1] + d[3],
+			d[0] - d[2],
+			d[1] - d[3],
 		};
 		int word = 0, best = 0, next = 0;
-		for (int msg = 0 ; msg < W; ++msg) {
-			if (sum[msg] > best) {
+		for (int i = 0; i < N; ++i) {
+			int mag = std::abs(sum[i]);
+			int msg = i + N * (sum[i] < 0);
+			if (mag > best) {
 				next = best;
-				best = sum[msg];
+				best = mag;
 				word = msg;
-			} else if (sum[msg] > next) {
-				next = sum[msg];
+			} else if (mag > next) {
+				next = mag;
 			}
 		}
 		if (best == next)
@@ -128,7 +105,7 @@ template <>
 class HadamardDecoder<4>
 {
 	static const int K = 4;
-	static const int W = 1 << K;
+	static const int N = 1 << (K - 1);
 public:
 	int operator()(const int8_t *c)
 	{
@@ -139,321 +116,35 @@ public:
 			c[6] + c[7], c[6] - c[7],
 		};
 		int e[8] = {
-			d[0] + d[2], d[0] - d[2],
-			d[1] + d[3], d[1] - d[3],
-			d[4] + d[6], d[4] - d[6],
-			d[5] + d[7], d[5] - d[7],
+			d[0] + d[2],
+			d[1] + d[3],
+			d[0] - d[2],
+			d[1] - d[3],
+			d[4] + d[6],
+			d[5] + d[7],
+			d[4] - d[6],
+			d[5] - d[7],
 		};
-		int f[8] = {
-			e[0] + e[4], e[0] - e[4],
-			e[1] + e[5], e[1] - e[5],
-			e[2] + e[6], e[2] - e[6],
-			e[3] + e[7], e[3] - e[7],
-		};
-		int sum[W] = {
-			+ f[0],
-			+ f[4],
-			+ f[2],
-			+ f[6],
-			+ f[1],
-			+ f[5],
-			+ f[3],
-			+ f[7],
-			- f[0],
-			- f[4],
-			- f[2],
-			- f[6],
-			- f[1],
-			- f[5],
-			- f[3],
-			- f[7],
+		int sum[8] = {
+			e[0] + e[4],
+			e[1] + e[5],
+			e[2] + e[6],
+			e[3] + e[7],
+			e[0] - e[4],
+			e[1] - e[5],
+			e[2] - e[6],
+			e[3] - e[7],
 		};
 		int word = 0, best = 0, next = 0;
-		for (int msg = 0 ; msg < W; ++msg) {
-			if (sum[msg] > best) {
+		for (int i = 0; i < N; ++i) {
+			int mag = std::abs(sum[i]);
+			int msg = i + N * (sum[i] < 0);
+			if (mag > best) {
 				next = best;
-				best = sum[msg];
+				best = mag;
 				word = msg;
-			} else if (sum[msg] > next) {
-				next = sum[msg];
-			}
-		}
-		if (best == next)
-			return -1;
-		return word;
-	}
-};
-
-template <>
-class HadamardDecoder<5>
-{
-	static const int K = 5;
-	static const int W = 1 << K;
-public:
-	int operator()(const int8_t *c)
-	{
-		int d[16] = {
-			c[0] + c[1], c[0] - c[1],
-			c[2] + c[3], c[2] - c[3],
-			c[4] + c[5], c[4] - c[5],
-			c[6] + c[7], c[6] - c[7],
-			c[8] + c[9], c[8] - c[9],
-			c[10] + c[11], c[10] - c[11],
-			c[12] + c[13], c[12] - c[13],
-			c[14] + c[15], c[14] - c[15],
-		};
-		int e[16] = {
-			d[0] + d[2], d[0] - d[2],
-			d[1] + d[3], d[1] - d[3],
-			d[4] + d[6], d[4] - d[6],
-			d[5] + d[7], d[5] - d[7],
-			d[8] + d[10], d[8] - d[10],
-			d[9] + d[11], d[9] - d[11],
-			d[12] + d[14], d[12] - d[14],
-			d[13] + d[15], d[13] - d[15],
-		};
-		int f[16] = {
-			e[0] + e[4], e[0] - e[4],
-			e[1] + e[5], e[1] - e[5],
-			e[2] + e[6], e[2] - e[6],
-			e[3] + e[7], e[3] - e[7],
-			e[8] + e[12], e[8] - e[12],
-			e[9] + e[13], e[9] - e[13],
-			e[10] + e[14], e[10] - e[14],
-			e[11] + e[15], e[11] - e[15],
-		};
-		int g[16] = {
-			f[0] + f[8], f[0] - f[8],
-			f[1] + f[9], f[1] - f[9],
-			f[2] + f[10], f[2] - f[10],
-			f[3] + f[11], f[3] - f[11],
-			f[4] + f[12], f[4] - f[12],
-			f[5] + f[13], f[5] - f[13],
-			f[6] + f[14], f[6] - f[14],
-			f[7] + f[15], f[7] - f[15],
-		};
-		int sum[W] = {
-			+ g[0],
-			+ g[8],
-			+ g[4],
-			+ g[12],
-			+ g[2],
-			+ g[10],
-			+ g[6],
-			+ g[14],
-			+ g[1],
-			+ g[9],
-			+ g[5],
-			+ g[13],
-			+ g[3],
-			+ g[11],
-			+ g[7],
-			+ g[15],
-			- g[0],
-			- g[8],
-			- g[4],
-			- g[12],
-			- g[2],
-			- g[10],
-			- g[6],
-			- g[14],
-			- g[1],
-			- g[9],
-			- g[5],
-			- g[13],
-			- g[3],
-			- g[11],
-			- g[7],
-			- g[15],
-		};
-		int word = 0, best = 0, next = 0;
-		for (int msg = 0 ; msg < W; ++msg) {
-			if (sum[msg] > best) {
-				next = best;
-				best = sum[msg];
-				word = msg;
-			} else if (sum[msg] > next) {
-				next = sum[msg];
-			}
-		}
-		if (best == next)
-			return -1;
-		return word;
-	}
-};
-
-template <>
-class HadamardDecoder<6>
-{
-	static const int K = 6;
-	static const int W = 1 << K;
-public:
-	int operator()(const int8_t *c)
-	{
-		int d[32] = {
-			c[0] + c[1], c[0] - c[1],
-			c[2] + c[3], c[2] - c[3],
-			c[4] + c[5], c[4] - c[5],
-			c[6] + c[7], c[6] - c[7],
-			c[8] + c[9], c[8] - c[9],
-			c[10] + c[11], c[10] - c[11],
-			c[12] + c[13], c[12] - c[13],
-			c[14] + c[15], c[14] - c[15],
-			c[16] + c[17], c[16] - c[17],
-			c[18] + c[19], c[18] - c[19],
-			c[20] + c[21], c[20] - c[21],
-			c[22] + c[23], c[22] - c[23],
-			c[24] + c[25], c[24] - c[25],
-			c[26] + c[27], c[26] - c[27],
-			c[28] + c[29], c[28] - c[29],
-			c[30] + c[31], c[30] - c[31],
-		};
-		int e[32] = {
-			d[0] + d[2], d[0] - d[2],
-			d[1] + d[3], d[1] - d[3],
-			d[4] + d[6], d[4] - d[6],
-			d[5] + d[7], d[5] - d[7],
-			d[8] + d[10], d[8] - d[10],
-			d[9] + d[11], d[9] - d[11],
-			d[12] + d[14], d[12] - d[14],
-			d[13] + d[15], d[13] - d[15],
-			d[16] + d[18], d[16] - d[18],
-			d[17] + d[19], d[17] - d[19],
-			d[20] + d[22], d[20] - d[22],
-			d[21] + d[23], d[21] - d[23],
-			d[24] + d[26], d[24] - d[26],
-			d[25] + d[27], d[25] - d[27],
-			d[28] + d[30], d[28] - d[30],
-			d[29] + d[31], d[29] - d[31],
-		};
-		int f[32] = {
-			e[0] + e[4], e[0] - e[4],
-			e[1] + e[5], e[1] - e[5],
-			e[2] + e[6], e[2] - e[6],
-			e[3] + e[7], e[3] - e[7],
-			e[8] + e[12], e[8] - e[12],
-			e[9] + e[13], e[9] - e[13],
-			e[10] + e[14], e[10] - e[14],
-			e[11] + e[15], e[11] - e[15],
-			e[16] + e[20], e[16] - e[20],
-			e[17] + e[21], e[17] - e[21],
-			e[18] + e[22], e[18] - e[22],
-			e[19] + e[23], e[19] - e[23],
-			e[24] + e[28], e[24] - e[28],
-			e[25] + e[29], e[25] - e[29],
-			e[26] + e[30], e[26] - e[30],
-			e[27] + e[31], e[27] - e[31],
-		};
-		int g[32] = {
-			f[0] + f[8], f[0] - f[8],
-			f[1] + f[9], f[1] - f[9],
-			f[2] + f[10], f[2] - f[10],
-			f[3] + f[11], f[3] - f[11],
-			f[4] + f[12], f[4] - f[12],
-			f[5] + f[13], f[5] - f[13],
-			f[6] + f[14], f[6] - f[14],
-			f[7] + f[15], f[7] - f[15],
-			f[16] + f[24], f[16] - f[24],
-			f[17] + f[25], f[17] - f[25],
-			f[18] + f[26], f[18] - f[26],
-			f[19] + f[27], f[19] - f[27],
-			f[20] + f[28], f[20] - f[28],
-			f[21] + f[29], f[21] - f[29],
-			f[22] + f[30], f[22] - f[30],
-			f[23] + f[31], f[23] - f[31],
-		};
-		int h[32] = {
-			g[0] + g[16], g[0] - g[16],
-			g[1] + g[17], g[1] - g[17],
-			g[2] + g[18], g[2] - g[18],
-			g[3] + g[19], g[3] - g[19],
-			g[4] + g[20], g[4] - g[20],
-			g[5] + g[21], g[5] - g[21],
-			g[6] + g[22], g[6] - g[22],
-			g[7] + g[23], g[7] - g[23],
-			g[8] + g[24], g[8] - g[24],
-			g[9] + g[25], g[9] - g[25],
-			g[10] + g[26], g[10] - g[26],
-			g[11] + g[27], g[11] - g[27],
-			g[12] + g[28], g[12] - g[28],
-			g[13] + g[29], g[13] - g[29],
-			g[14] + g[30], g[14] - g[30],
-			g[15] + g[31], g[15] - g[31],
-		};
-		int sum[W] = {
-			+ h[0],
-			+ h[16],
-			+ h[8],
-			+ h[24],
-			+ h[4],
-			+ h[20],
-			+ h[12],
-			+ h[28],
-			+ h[2],
-			+ h[18],
-			+ h[10],
-			+ h[26],
-			+ h[6],
-			+ h[22],
-			+ h[14],
-			+ h[30],
-			+ h[1],
-			+ h[17],
-			+ h[9],
-			+ h[25],
-			+ h[5],
-			+ h[21],
-			+ h[13],
-			+ h[29],
-			+ h[3],
-			+ h[19],
-			+ h[11],
-			+ h[27],
-			+ h[7],
-			+ h[23],
-			+ h[15],
-			+ h[31],
-			- h[0],
-			- h[16],
-			- h[8],
-			- h[24],
-			- h[4],
-			- h[20],
-			- h[12],
-			- h[28],
-			- h[2],
-			- h[18],
-			- h[10],
-			- h[26],
-			- h[6],
-			- h[22],
-			- h[14],
-			- h[30],
-			- h[1],
-			- h[17],
-			- h[9],
-			- h[25],
-			- h[5],
-			- h[21],
-			- h[13],
-			- h[29],
-			- h[3],
-			- h[19],
-			- h[11],
-			- h[27],
-			- h[7],
-			- h[23],
-			- h[15],
-			- h[31],
-		};
-		int word = 0, best = 0, next = 0;
-		for (int msg = 0 ; msg < W; ++msg) {
-			if (sum[msg] > best) {
-				next = best;
-				best = sum[msg];
-				word = msg;
-			} else if (sum[msg] > next) {
-				next = sum[msg];
+			} else if (mag > next) {
+				next = mag;
 			}
 		}
 		if (best == next)