===================================================================
--- original.js
+++ change.js
@@ -7,9 +7,10 @@
 	self.pixelSize = 32;
 	self.modules = [];
 	self.string = string;
 	self.countBitLength = 10;
-	self.codeWord = "";
+	self.dataCodeWord = "";
+	self.eccCodeWord = "";
 	self.size = 21;
 	// Block = 8 bits
 	self.maxDataBlock = 19;
 	self.maxErrorBlock = 7;
@@ -45,55 +46,109 @@
 		for (var i = 8; i <= self.size - 8; i += 2) {
 			self.placePixel(i, 6);
 			self.placePixel(6, i);
 		}
-		// Draw dataCodeWord and eccCodeWord in a zigzag pattern, avoiding position, timing, and format patterns
-		// For now, we only have self.codeWord (dataCodeWord), but this is extensible for eccCodeWord
-		var size = self.size;
-		var codeBits = self.codeWord;
-		var bitIndex = 0;
-		// Helper to check if a module is reserved (position, timing, format)
-		function isReserved(x, y) {
-			// Position patterns (top-left, top-right, bottom-left)
-			if (x <= 8 && y <= 8 ||
-			// top-left
-			x >= size - 8 && y <= 8 ||
-			// top-right
-			x <= 8 && y >= size - 8) {
-				// bottom-left
-				return true;
+		var x = size - 1;
+		var y = size - 1;
+		var dir = [-1, 0];
+		for (var i = 0; i < 6; i++) {
+			if (self.dataCodeWord[i] == 1) {
+				self.placePixel(x, y);
 			}
-			// Timing patterns (row 6, col 6, except where they overlap position patterns)
-			if (y === 6 && x >= 8 && x <= size - 9 || x === 6 && y >= 8 && y <= size - 9) {
-				return true;
+			y++;
+		}
+	};
+	// Convert to hexadecimal and split into bytes
+	self.binToHex = function (bin) {
+		var hexBytes = "";
+		for (var i = 0; i < bin.length; i += 8) {
+			var _byte = bin.substr(i, 8);
+			var hexValue = parseInt(_byte, 2).toString(16).toUpperCase();
+			if (hexValue.length === 1) {
+				hexValue = "0" + hexValue;
 			}
-			// Format info (beside position patterns)
-			if (y === 8 && x <= 8 || x === 8 && y <= 8) return true; // top-left
-			if (y === 8 && x >= size - 8 || x === size - 8 && y <= 8) return true; // top-right
-			if (x === 8 && y >= size - 8 || y === size - 8 && x <= 8) return true; // bottom-left
-			return false;
+			hexBytes += hexValue + " ";
 		}
-		// Zigzag from bottom-right, two columns at a time, upwards then downwards
-		var dir = -1; // -1: up, 1: down
-		for (var col = size - 1; col > 0; col -= 2) {
-			if (col === 6) col--; // skip vertical timing pattern
-			var rowStart = dir === -1 ? size - 1 : 0;
-			var rowEnd = dir === -1 ? -1 : size;
-			for (var row = rowStart; row !== rowEnd; row += dir) {
-				for (var c = 0; c < 2; c++) {
-					var x = col - c;
-					var y = row;
-					if (x < 0 || y < 0 || x >= size || y >= size) continue;
-					if (isReserved(x, y)) continue;
-					if (bitIndex >= codeBits.length) continue;
-					if (codeBits[bitIndex] === "1") {
-						self.placePixel(x, y);
-					}
-					bitIndex++;
+		return hexBytes;
+	};
+	self.encodeECC = function () {
+		var LOG_TABLE = new Array(256);
+		var EXP_TABLE = new Array(256);
+		var p = 1;
+		for (var i = 0; i < 255; i++) {
+			EXP_TABLE[i] = p;
+			LOG_TABLE[p] = i;
+			p = p << 1;
+			if (p > 255) {
+				p = p ^ 285;
+			}
+		}
+		EXP_TABLE[255] = 1;
+		var gf_multiply = function gf_multiply(a, b) {
+			if (a === 0 || b === 0) {
+				return 0;
+			}
+			return EXP_TABLE[(LOG_TABLE[a] + LOG_TABLE[b]) % 255];
+		};
+		var getGeneratorPolynomial = function getGeneratorPolynomial(numEccBytes) {
+			var g = [1];
+			for (var i = 0; i < numEccBytes; i++) {
+				var next_g = new Array(g.length + 1);
+				for (var k = 0; k < next_g.length; k++) {
+					next_g[k] = 0;
 				}
+				var alpha_pow_i = EXP_TABLE[i];
+				for (var j = 0; j < g.length; j++) {
+					next_g[j] = g[j];
+				}
+				for (var j = 0; j < g.length; j++) {
+					next_g[j + 1] ^= gf_multiply(g[j], alpha_pow_i);
+				}
+				g = next_g;
 			}
-			dir *= -1; // reverse direction
+			return g;
+		};
+		// 1. Convert dataCodeWord to bytes
+		var dataBytes = [];
+		for (var i = 0; i < self.dataCodeWord.length; i += 8) {
+			var byteString = self.dataCodeWord.substr(i, 8);
+			dataBytes.push(parseInt(byteString, 2));
 		}
+		// 2. Get generator polynomial
+		var generator = getGeneratorPolynomial(self.maxErrorBlock);
+		// 3. Perform polynomial division to get ECC
+		var dataLen = dataBytes.length;
+		var eccLen = self.maxErrorBlock;
+		var msg_out = new Array(dataLen + eccLen);
+		for (var i = 0; i < msg_out.length; i++) {
+			msg_out[i] = 0;
+		}
+		for (var i = 0; i < dataLen; i++) {
+			msg_out[i] = dataBytes[i];
+		}
+		for (var i = 0; i < dataLen; i++) {
+			var coef = msg_out[i];
+			if (coef !== 0) {
+				for (var j = 0; j < generator.length; j++) {
+					msg_out[i + j] ^= gf_multiply(generator[j], coef);
+				}
+			}
+		}
+		var eccBytes = [];
+		for (var i = 0; i < eccLen; i++) {
+			eccBytes.push(msg_out[dataLen + i]);
+		}
+		// 4. Convert ECC bytes to binary string
+		var eccBinaryString = "";
+		for (var i = 0; i < eccBytes.length; i++) {
+			var binary = eccBytes[i].toString(2);
+			while (binary.length < 8) {
+				binary = "0" + binary;
+			}
+			eccBinaryString += binary;
+		}
+		self.eccCodeWord = eccBinaryString;
+		console.log("eccCodeWord: " + self.binToHex(self.eccCodeWord));
 	};
 	// Encode numeric data method
 	self.encodeNumeric = function () {
 		// Split into groups of 3 digits
@@ -121,26 +176,43 @@
 			while (binary.length < bitLength) {
 				binary = "0" + binary;
 			}
 			binaryGroups.push(binary);
-			console.log("Group '" + groups[j] + "' -> " + num + " -> " + binary + " (" + bitLength + " bits)");
+			console.log("Group " + num + " -> " + binary + " (" + bitLength + " bits)");
 		}
 		console.log("Message Binary: " + binaryGroups.join(" ") + " (" + binaryGroups.join("").length + " bits)");
-		self.codeWord += "0001";
+		self.dataCodeWord += "0001";
 		var binary = string.length.toString(2);
 		// Convert to binary with proper padding
 		while (binary.length < self.countBitLength) {
 			binary = "0" + binary;
 		}
-		self.codeWord += binary;
-		self.codeWord += binaryGroups.join("");
-		self.codeWord += "0000"; // Terminator
-		while (self.codeWord.length % 8 != 0) {
-			self.codeWord += "0";
+		self.dataCodeWord += binary;
+		self.dataCodeWord += binaryGroups.join("");
+		self.dataCodeWord += "0000"; // Terminator
+		// Add byte padding
+		var currentBytes = self.dataCodeWord.length / 8;
+		var bytesNeeded = self.maxDataBlock - currentBytes;
+		// Pad to byte boundary first
+		var bitsToNextByte = self.dataCodeWord.length % 8;
+		if (bitsToNextByte > 0) {
+			var padBits = 8 - bitsToNextByte;
+			for (var p = 0; p < padBits; p++) {
+				self.dataCodeWord += "0";
+			}
 		}
-		console.log("codeWord: " + self.codeWord + " (" + self.codeWord.length / 8 + " bytes)");
+		console.log("dataCodeWord: " + self.dataCodeWord + " (" + self.dataCodeWord.length / 8 + " bytes)");
+		// Add alternating padding bytes (11101100 and 00010001)
+		var paddingBytes = ["11101100", "00010001"];
+		var paddingIndex = 0;
+		while (self.dataCodeWord.length / 8 < self.maxDataBlock) {
+			self.dataCodeWord += paddingBytes[paddingIndex];
+			paddingIndex = (paddingIndex + 1) % 2;
+		}
+		console.log("dataCodeWord with padding: " + self.binToHex(self.dataCodeWord));
 	};
 	self.encodeNumeric();
+	self.encodeECC();
 	self.createPattern();
 	return self;
 });