qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/qrcode/FormatInformation.h

@@ -0,0 +1,54 @@
+#ifndef __FORMAT_INFORMATION_H__
+#define __FORMAT_INFORMATION_H__
+
+/*
+ *  FormatInformation.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/qrcode/ErrorCorrectionLevel.h>
+#include <zxing/common/Counted.h>
+#include <iostream>
+
+namespace zxing {
+namespace qrcode {
+
+class FormatInformation : public Counted {
+private:
+  static int FORMAT_INFO_MASK_QR;
+  static int FORMAT_INFO_DECODE_LOOKUP[][2];
+  static int N_FORMAT_INFO_DECODE_LOOKUPS;
+  static int BITS_SET_IN_HALF_BYTE[];
+
+  ErrorCorrectionLevel &errorCorrectionLevel_;
+  unsigned char dataMask_;
+
+  FormatInformation(int formatInfo);
+
+public:
+  static int numBitsDiffering(unsigned int a, unsigned int b);
+  static Ref<FormatInformation> decodeFormatInformation(int rawFormatInfo);
+  static Ref<FormatInformation> doDecodeFormatInformation(int rawFormatInfo);
+  ErrorCorrectionLevel &getErrorCorrectionLevel();
+  unsigned char getDataMask();
+  friend bool operator==(const FormatInformation &a, const FormatInformation &b);
+  friend std::ostream& operator<<(std::ostream& out, const FormatInformation& fi);
+};
+}
+}
+
+#endif // __FORMAT_INFORMATION_H__

data/ext/qrscanner/zxing/core/src/zxing/qrcode/QRCodeReader.cpp

@@ -0,0 +1,82 @@
+/*
+ *  QRCodeReader.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/qrcode/QRCodeReader.h>
+#include <zxing/qrcode/detector/Detector.h>
+
+#include <iostream>
+
+namespace zxing {
+	namespace qrcode {
+		
+		using namespace std;
+		
+		QRCodeReader::QRCodeReader() :decoder_() {
+		}
+		//TODO: see if any of the other files in the qrcode tree need tryHarder
+		Ref<Result> QRCodeReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+#ifdef DEBUG
+			cout << "decoding image " << image.object_ << ":\n" << flush;
+#endif
+			
+			Detector detector(image->getBlackMatrix());
+			
+			
+#ifdef DEBUG
+			cout << "(1) created detector " << &detector << "\n" << flush;
+#endif
+			
+			Ref<DetectorResult> detectorResult(detector.detect(hints));
+#ifdef DEBUG
+			cout << "(2) detected, have detectorResult " << detectorResult.object_ << "\n" << flush;
+#endif
+			
+			std::vector<Ref<ResultPoint> > points(detectorResult->getPoints());
+			
+			
+#ifdef DEBUG
+			cout << "(3) extracted points " << &points << "\n" << flush;
+			cout << "found " << points->size() << " points:\n";
+			for (size_t i = 0; i < points->size(); i++) {
+				cout << "   " << points[i]->getX() << "," << points[i]->getY() << "\n";
+			}
+			cout << "bits:\n";
+			cout << *(detectorResult->getBits()) << "\n";
+#endif
+			
+			Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult->getBits()));
+#ifdef DEBUG
+			cout << "(4) decoded, have decoderResult " << decoderResult.object_ << "\n" << flush;
+#endif
+			
+			Ref<Result> result(
+							   new Result(decoderResult->getText(), decoderResult->getRawBytes(), points, BarcodeFormat_QR_CODE));
+#ifdef DEBUG
+			cout << "(5) created result " << result.object_ << ", returning\n" << flush;
+#endif
+			
+			return result;
+		}
+		
+		QRCodeReader::~QRCodeReader() {
+		}
+		
+	}
+}

data/ext/qrscanner/zxing/core/src/zxing/qrcode/QRCodeReader.h

@@ -0,0 +1,43 @@
+#ifndef __QR_CODE_READER_H__
+#define __QR_CODE_READER_H__
+
+/*
+ *  QRCodeReader.h
+ *  zxing
+ *
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/Reader.h>
+#include <zxing/qrcode/decoder/Decoder.h>
+#include <zxing/DecodeHints.h>
+
+namespace zxing {
+	namespace qrcode {
+		
+		class QRCodeReader : public Reader {
+		private:
+			Decoder decoder_;
+			
+		public:
+			QRCodeReader();
+			virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+			virtual ~QRCodeReader();
+			
+		};
+	}
+}
+
+#endif // __QR_CODE_READER_H__

data/ext/qrscanner/zxing/core/src/zxing/qrcode/Version.cpp

@@ -0,0 +1,557 @@
+/*
+ *  Version.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 14/05/2008.
+ *  Copyright 2008 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/qrcode/Version.h>
+#include <zxing/qrcode/FormatInformation.h>
+#include <limits>
+#include <iostream>
+#include <cstdarg>
+
+namespace zxing {
+namespace qrcode {
+using namespace std;
+
+ECB::ECB(int count, int dataCodewords) :
+    count_(count), dataCodewords_(dataCodewords) {
+}
+
+int ECB::getCount() {
+  return count_;
+}
+
+int ECB::getDataCodewords() {
+  return dataCodewords_;
+}
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
+    ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {
+}
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
+    ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
+  ecBlocks_.push_back(ecBlocks2);
+}
+
+int ECBlocks::getECCodewords() {
+  return ecCodewords_;
+}
+
+std::vector<ECB*>& ECBlocks::getECBlocks() {
+  return ecBlocks_;
+}
+
+ECBlocks::~ECBlocks() {
+  for (size_t i = 0; i < ecBlocks_.size(); i++) {
+    delete ecBlocks_[i];
+  }
+}
+
+unsigned int Version::VERSION_DECODE_INFO[] = { 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, 0x0C762, 0x0D847, 0x0E60D,
+    0x0F928, 0x10B78, 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
+    0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, 0x2542E, 0x26A64,
+    0x27541, 0x28C69
+                                              };
+int Version::N_VERSION_DECODE_INFOS = 34;
+vector<Ref<Version> > Version::VERSIONS;
+static int N_VERSIONS = Version::buildVersions();
+
+int Version::getVersionNumber() {
+  return versionNumber_;
+}
+
+vector<int> &Version::getAlignmentPatternCenters() {
+  return alignmentPatternCenters_;
+}
+
+int Version::getTotalCodewords() {
+  return totalCodewords_;
+}
+
+int Version::getDimensionForVersion() {
+  return 17 + 4 * versionNumber_;
+}
+
+ECBlocks& Version::getECBlocksForLevel(ErrorCorrectionLevel &ecLevel) {
+  return *ecBlocks_[ecLevel.ordinal()];
+}
+
+Version *Version::getProvisionalVersionForDimension(int dimension) {
+  if (dimension % 4 != 1) {
+    throw ReaderException("Dimension must be 1 mod 4");
+  }
+  return Version::getVersionForNumber((dimension - 17) >> 2);
+}
+
+Version *Version::getVersionForNumber(int versionNumber) {
+  if (versionNumber < 1 || versionNumber > N_VERSIONS) {
+    throw ReaderException("versionNumber must be between 1 and 40");
+  }
+
+  return VERSIONS[versionNumber - 1];
+}
+
+Version::Version(int versionNumber, vector<int> *alignmentPatternCenters, ECBlocks *ecBlocks1, ECBlocks *ecBlocks2,
+                 ECBlocks *ecBlocks3, ECBlocks *ecBlocks4) :
+    versionNumber_(versionNumber), alignmentPatternCenters_(*alignmentPatternCenters), ecBlocks_(4), totalCodewords_(0) {
+  ecBlocks_[0] = ecBlocks1;
+  ecBlocks_[1] = ecBlocks2;
+  ecBlocks_[2] = ecBlocks3;
+  ecBlocks_[3] = ecBlocks4;
+
+  int total = 0;
+  int ecCodewords = ecBlocks1->getECCodewords();
+  vector<ECB*> &ecbArray = ecBlocks1->getECBlocks();
+  for (size_t i = 0; i < ecbArray.size(); i++) {
+    ECB *ecBlock = ecbArray[i];
+    total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
+  }
+  totalCodewords_ = total;
+}
+
+Version::~Version() {
+  delete &alignmentPatternCenters_;
+  for (size_t i = 0; i < ecBlocks_.size(); i++) {
+    delete ecBlocks_[i];
+  }
+}
+
+Version *Version::decodeVersionInformation(unsigned int versionBits) {
+  int bestDifference = numeric_limits<int>::max();
+  size_t bestVersion = 0;
+  for (int i = 0; i < N_VERSION_DECODE_INFOS; i++) {
+    unsigned targetVersion = VERSION_DECODE_INFO[i];
+    // Do the version info bits match exactly? done.
+    if (targetVersion == versionBits) {
+      return getVersionForNumber(i + 7);
+    }
+    // Otherwise see if this is the closest to a real version info bit
+    // string we have seen so far
+    int bitsDifference = FormatInformation::numBitsDiffering(versionBits, targetVersion);
+    if (bitsDifference < bestDifference) {
+      bestVersion = i + 7;
+      bestDifference = bitsDifference;
+    }
+  }
+  // We can tolerate up to 3 bits of error since no two version info codewords will
+  // differ in less than 4 bits.
+  if (bestDifference <= 3) {
+    return getVersionForNumber(bestVersion);
+  }
+  // If we didn't find a close enough match, fail
+  return 0;
+}
+
+Ref<BitMatrix> Version::buildFunctionPattern() {
+  int dimension = getDimensionForVersion();
+  Ref<BitMatrix> functionPattern(new BitMatrix(dimension));
+
+
+  // Top left finder pattern + separator + format
+  functionPattern->setRegion(0, 0, 9, 9);
+  // Top right finder pattern + separator + format
+  functionPattern->setRegion(dimension - 8, 0, 8, 9);
+  // Bottom left finder pattern + separator + format
+  functionPattern->setRegion(0, dimension - 8, 9, 8);
+
+
+  // Alignment patterns
+  size_t max = alignmentPatternCenters_.size();
+  for (size_t x = 0; x < max; x++) {
+    int i = alignmentPatternCenters_[x] - 2;
+    for (size_t y = 0; y < max; y++) {
+      if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
+        // No alignment patterns near the three finder patterns
+        continue;
+      }
+      functionPattern->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5);
+    }
+  }
+
+  // Vertical timing pattern
+  functionPattern->setRegion(6, 9, 1, dimension - 17);
+  // Horizontal timing pattern
+  functionPattern->setRegion(9, 6, dimension - 17, 1);
+
+  if (versionNumber_ > 6) {
+    // Version info, top right
+    functionPattern->setRegion(dimension - 11, 0, 3, 6);
+    // Version info, bottom left
+    functionPattern->setRegion(0, dimension - 11, 6, 3);
+  }
+
+
+  //#ifdef DEBUG
+  //	cout << "version " << versionNumber_ << " built function pattern:\n";
+  //	cout << *functionPattern;
+  //#endif
+
+  return functionPattern;
+}
+
+static vector<int> *intArray(size_t n...) {
+  va_list ap;
+  va_start(ap, n);
+  vector<int> *result = new vector<int>(n);
+  for (size_t i = 0; i < n; i++) {
+    (*result)[i] = va_arg(ap, int);
+  }
+  va_end(ap);
+  return result;
+}
+
+int Version::buildVersions() {
+  VERSIONS.push_back(Ref<Version>(new Version(1, intArray(0),
+                                  new ECBlocks(7, new ECB(1, 19)),
+                                  new ECBlocks(10, new ECB(1, 16)),
+                                  new ECBlocks(13, new ECB(1, 13)),
+                                  new ECBlocks(17, new ECB(1, 9)))));
+  VERSIONS.push_back(Ref<Version>(new Version(2, intArray(2, 6, 18),
+                                  new ECBlocks(10, new ECB(1, 34)),
+                                  new ECBlocks(16, new ECB(1, 28)),
+                                  new ECBlocks(22, new ECB(1, 22)),
+                                  new ECBlocks(28, new ECB(1, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(3, intArray(2, 6, 22),
+                                  new ECBlocks(15, new ECB(1, 55)),
+                                  new ECBlocks(26, new ECB(1, 44)),
+                                  new ECBlocks(18, new ECB(2, 17)),
+                                  new ECBlocks(22, new ECB(2, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(4, intArray(2, 6, 26),
+                                  new ECBlocks(20, new ECB(1, 80)),
+                                  new ECBlocks(18, new ECB(2, 32)),
+                                  new ECBlocks(26, new ECB(2, 24)),
+                                  new ECBlocks(16, new ECB(4, 9)))));
+  VERSIONS.push_back(Ref<Version>(new Version(5, intArray(2, 6, 30),
+                                  new ECBlocks(26, new ECB(1, 108)),
+                                  new ECBlocks(24, new ECB(2, 43)),
+                                  new ECBlocks(18, new ECB(2, 15),
+                                               new ECB(2, 16)),
+                                  new ECBlocks(22, new ECB(2, 11),
+                                               new ECB(2, 12)))));
+  VERSIONS.push_back(Ref<Version>(new Version(6, intArray(2, 6, 34),
+                                  new ECBlocks(18, new ECB(2, 68)),
+                                  new ECBlocks(16, new ECB(4, 27)),
+                                  new ECBlocks(24, new ECB(4, 19)),
+                                  new ECBlocks(28, new ECB(4, 15)))));
+  VERSIONS.push_back(Ref<Version>(new Version(7, intArray(3, 6, 22, 38),
+                                  new ECBlocks(20, new ECB(2, 78)),
+                                  new ECBlocks(18, new ECB(4, 31)),
+                                  new ECBlocks(18, new ECB(2, 14),
+                                               new ECB(4, 15)),
+                                  new ECBlocks(26, new ECB(4, 13),
+                                               new ECB(1, 14)))));
+  VERSIONS.push_back(Ref<Version>(new Version(8, intArray(3, 6, 24, 42),
+                                  new ECBlocks(24, new ECB(2, 97)),
+                                  new ECBlocks(22, new ECB(2, 38),
+                                               new ECB(2, 39)),
+                                  new ECBlocks(22, new ECB(4, 18),
+                                               new ECB(2, 19)),
+                                  new ECBlocks(26, new ECB(4, 14),
+                                               new ECB(2, 15)))));
+  VERSIONS.push_back(Ref<Version>(new Version(9, intArray(3, 6, 26, 46),
+                                  new ECBlocks(30, new ECB(2, 116)),
+                                  new ECBlocks(22, new ECB(3, 36),
+                                               new ECB(2, 37)),
+                                  new ECBlocks(20, new ECB(4, 16),
+                                               new ECB(4, 17)),
+                                  new ECBlocks(24, new ECB(4, 12),
+                                               new ECB(4, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(10, intArray(3, 6, 28, 50),
+                                  new ECBlocks(18, new ECB(2, 68),
+                                               new ECB(2, 69)),
+                                  new ECBlocks(26, new ECB(4, 43),
+                                               new ECB(1, 44)),
+                                  new ECBlocks(24, new ECB(6, 19),
+                                               new ECB(2, 20)),
+                                  new ECBlocks(28, new ECB(6, 15),
+                                               new ECB(2, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(11, intArray(3, 6, 30, 54),
+                                  new ECBlocks(20, new ECB(4, 81)),
+                                  new ECBlocks(30, new ECB(1, 50),
+                                               new ECB(4, 51)),
+                                  new ECBlocks(28, new ECB(4, 22),
+                                               new ECB(4, 23)),
+                                  new ECBlocks(24, new ECB(3, 12),
+                                               new ECB(8, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(12, intArray(3, 6, 32, 58),
+                                  new ECBlocks(24, new ECB(2, 92),
+                                               new ECB(2, 93)),
+                                  new ECBlocks(22, new ECB(6, 36),
+                                               new ECB(2, 37)),
+                                  new ECBlocks(26, new ECB(4, 20),
+                                               new ECB(6, 21)),
+                                  new ECBlocks(28, new ECB(7, 14),
+                                               new ECB(4, 15)))));
+  VERSIONS.push_back(Ref<Version>(new Version(13, intArray(3, 6, 34, 62),
+                                  new ECBlocks(26, new ECB(4, 107)),
+                                  new ECBlocks(22, new ECB(8, 37),
+                                               new ECB(1, 38)),
+                                  new ECBlocks(24, new ECB(8, 20),
+                                               new ECB(4, 21)),
+                                  new ECBlocks(22, new ECB(12, 11),
+                                               new ECB(4, 12)))));
+  VERSIONS.push_back(Ref<Version>(new Version(14, intArray(4, 6, 26, 46, 66),
+                                  new ECBlocks(30, new ECB(3, 115),
+                                               new ECB(1, 116)),
+                                  new ECBlocks(24, new ECB(4, 40),
+                                               new ECB(5, 41)),
+                                  new ECBlocks(20, new ECB(11, 16),
+                                               new ECB(5, 17)),
+                                  new ECBlocks(24, new ECB(11, 12),
+                                               new ECB(5, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(15, intArray(4, 6, 26, 48, 70),
+                                  new ECBlocks(22, new ECB(5, 87),
+                                               new ECB(1, 88)),
+                                  new ECBlocks(24, new ECB(5, 41),
+                                               new ECB(5, 42)),
+                                  new ECBlocks(30, new ECB(5, 24),
+                                               new ECB(7, 25)),
+                                  new ECBlocks(24, new ECB(11, 12),
+                                               new ECB(7, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(16, intArray(4, 6, 26, 50, 74),
+                                  new ECBlocks(24, new ECB(5, 98),
+                                               new ECB(1, 99)),
+                                  new ECBlocks(28, new ECB(7, 45),
+                                               new ECB(3, 46)),
+                                  new ECBlocks(24, new ECB(15, 19),
+                                               new ECB(2, 20)),
+                                  new ECBlocks(30, new ECB(3, 15),
+                                               new ECB(13, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(17, intArray(4, 6, 30, 54, 78),
+                                  new ECBlocks(28, new ECB(1, 107),
+                                               new ECB(5, 108)),
+                                  new ECBlocks(28, new ECB(10, 46),
+                                               new ECB(1, 47)),
+                                  new ECBlocks(28, new ECB(1, 22),
+                                               new ECB(15, 23)),
+                                  new ECBlocks(28, new ECB(2, 14),
+                                               new ECB(17, 15)))));
+  VERSIONS.push_back(Ref<Version>(new Version(18, intArray(4, 6, 30, 56, 82),
+                                  new ECBlocks(30, new ECB(5, 120),
+                                               new ECB(1, 121)),
+                                  new ECBlocks(26, new ECB(9, 43),
+                                               new ECB(4, 44)),
+                                  new ECBlocks(28, new ECB(17, 22),
+                                               new ECB(1, 23)),
+                                  new ECBlocks(28, new ECB(2, 14),
+                                               new ECB(19, 15)))));
+  VERSIONS.push_back(Ref<Version>(new Version(19, intArray(4, 6, 30, 58, 86),
+                                  new ECBlocks(28, new ECB(3, 113),
+                                               new ECB(4, 114)),
+                                  new ECBlocks(26, new ECB(3, 44),
+                                               new ECB(11, 45)),
+                                  new ECBlocks(26, new ECB(17, 21),
+                                               new ECB(4, 22)),
+                                  new ECBlocks(26, new ECB(9, 13),
+                                               new ECB(16, 14)))));
+  VERSIONS.push_back(Ref<Version>(new Version(20, intArray(4, 6, 34, 62, 90),
+                                  new ECBlocks(28, new ECB(3, 107),
+                                               new ECB(5, 108)),
+                                  new ECBlocks(26, new ECB(3, 41),
+                                               new ECB(13, 42)),
+                                  new ECBlocks(30, new ECB(15, 24),
+                                               new ECB(5, 25)),
+                                  new ECBlocks(28, new ECB(15, 15),
+                                               new ECB(10, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(21, intArray(5, 6, 28, 50, 72, 94),
+                                  new ECBlocks(28, new ECB(4, 116),
+                                               new ECB(4, 117)),
+                                  new ECBlocks(26, new ECB(17, 42)),
+                                  new ECBlocks(28, new ECB(17, 22),
+                                               new ECB(6, 23)),
+                                  new ECBlocks(30, new ECB(19, 16),
+                                               new ECB(6, 17)))));
+  VERSIONS.push_back(Ref<Version>(new Version(22, intArray(5, 6, 26, 50, 74, 98),
+                                  new ECBlocks(28, new ECB(2, 111),
+                                               new ECB(7, 112)),
+                                  new ECBlocks(28, new ECB(17, 46)),
+                                  new ECBlocks(30, new ECB(7, 24),
+                                               new ECB(16, 25)),
+                                  new ECBlocks(24, new ECB(34, 13)))));
+  VERSIONS.push_back(Ref<Version>(new Version(23, intArray(5, 6, 30, 54, 78, 102),
+                                  new ECBlocks(30, new ECB(4, 121),
+                                               new ECB(5, 122)),
+                                  new ECBlocks(28, new ECB(4, 47),
+                                               new ECB(14, 48)),
+                                  new ECBlocks(30, new ECB(11, 24),
+                                               new ECB(14, 25)),
+                                  new ECBlocks(30, new ECB(16, 15),
+                                               new ECB(14, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(24, intArray(5, 6, 28, 54, 80, 106),
+                                  new ECBlocks(30, new ECB(6, 117),
+                                               new ECB(4, 118)),
+                                  new ECBlocks(28, new ECB(6, 45),
+                                               new ECB(14, 46)),
+                                  new ECBlocks(30, new ECB(11, 24),
+                                               new ECB(16, 25)),
+                                  new ECBlocks(30, new ECB(30, 16),
+                                               new ECB(2, 17)))));
+  VERSIONS.push_back(Ref<Version>(new Version(25, intArray(5, 6, 32, 58, 84, 110),
+                                  new ECBlocks(26, new ECB(8, 106),
+                                               new ECB(4, 107)),
+                                  new ECBlocks(28, new ECB(8, 47),
+                                               new ECB(13, 48)),
+                                  new ECBlocks(30, new ECB(7, 24),
+                                               new ECB(22, 25)),
+                                  new ECBlocks(30, new ECB(22, 15),
+                                               new ECB(13, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(26, intArray(5, 6, 30, 58, 86, 114),
+                                  new ECBlocks(28, new ECB(10, 114),
+                                               new ECB(2, 115)),
+                                  new ECBlocks(28, new ECB(19, 46),
+                                               new ECB(4, 47)),
+                                  new ECBlocks(28, new ECB(28, 22),
+                                               new ECB(6, 23)),
+                                  new ECBlocks(30, new ECB(33, 16),
+                                               new ECB(4, 17)))));
+  VERSIONS.push_back(Ref<Version>(new Version(27, intArray(5, 6, 34, 62, 90, 118),
+                                  new ECBlocks(30, new ECB(8, 122),
+                                               new ECB(4, 123)),
+                                  new ECBlocks(28, new ECB(22, 45),
+                                               new ECB(3, 46)),
+                                  new ECBlocks(30, new ECB(8, 23),
+                                               new ECB(26, 24)),
+                                  new ECBlocks(30, new ECB(12, 15),
+                                               new ECB(28, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
+                                  new ECBlocks(30, new ECB(3, 117),
+                                               new ECB(10, 118)),
+                                  new ECBlocks(28, new ECB(3, 45),
+                                               new ECB(23, 46)),
+                                  new ECBlocks(30, new ECB(4, 24),
+                                               new ECB(31, 25)),
+                                  new ECBlocks(30, new ECB(11, 15),
+                                               new ECB(31, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
+                                  new ECBlocks(30, new ECB(7, 116),
+                                               new ECB(7, 117)),
+                                  new ECBlocks(28, new ECB(21, 45),
+                                               new ECB(7, 46)),
+                                  new ECBlocks(30, new ECB(1, 23),
+                                               new ECB(37, 24)),
+                                  new ECBlocks(30, new ECB(19, 15),
+                                               new ECB(26, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
+                                  new ECBlocks(30, new ECB(5, 115),
+                                               new ECB(10, 116)),
+                                  new ECBlocks(28, new ECB(19, 47),
+                                               new ECB(10, 48)),
+                                  new ECBlocks(30, new ECB(15, 24),
+                                               new ECB(25, 25)),
+                                  new ECBlocks(30, new ECB(23, 15),
+                                               new ECB(25, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
+                                  new ECBlocks(30, new ECB(13, 115),
+                                               new ECB(3, 116)),
+                                  new ECBlocks(28, new ECB(2, 46),
+                                               new ECB(29, 47)),
+                                  new ECBlocks(30, new ECB(42, 24),
+                                               new ECB(1, 25)),
+                                  new ECBlocks(30, new ECB(23, 15),
+                                               new ECB(28, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(32, intArray(6, 6, 34, 60, 86, 112, 138),
+                                  new ECBlocks(30, new ECB(17, 115)),
+                                  new ECBlocks(28, new ECB(10, 46),
+                                               new ECB(23, 47)),
+                                  new ECBlocks(30, new ECB(10, 24),
+                                               new ECB(35, 25)),
+                                  new ECBlocks(30, new ECB(19, 15),
+                                               new ECB(35, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
+                                  new ECBlocks(30, new ECB(17, 115),
+                                               new ECB(1, 116)),
+                                  new ECBlocks(28, new ECB(14, 46),
+                                               new ECB(21, 47)),
+                                  new ECBlocks(30, new ECB(29, 24),
+                                               new ECB(19, 25)),
+                                  new ECBlocks(30, new ECB(11, 15),
+                                               new ECB(46, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
+                                  new ECBlocks(30, new ECB(13, 115),
+                                               new ECB(6, 116)),
+                                  new ECBlocks(28, new ECB(14, 46),
+                                               new ECB(23, 47)),
+                                  new ECBlocks(30, new ECB(44, 24),
+                                               new ECB(7, 25)),
+                                  new ECBlocks(30, new ECB(59, 16),
+                                               new ECB(1, 17)))));
+  VERSIONS.push_back(Ref<Version>(new Version(35, intArray(7, 6, 30, 54, 78,
+                                  102, 126, 150),
+                                  new ECBlocks(30, new ECB(12, 121),
+                                               new ECB(7, 122)),
+                                  new ECBlocks(28, new ECB(12, 47),
+                                               new ECB(26, 48)),
+                                  new ECBlocks(30, new ECB(39, 24),
+                                               new ECB(14, 25)),
+                                  new ECBlocks(30, new ECB(22, 15),
+                                               new ECB(41, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(36, intArray(7, 6, 24, 50, 76,
+                                  102, 128, 154),
+                                  new ECBlocks(30, new ECB(6, 121),
+                                               new ECB(14, 122)),
+                                  new ECBlocks(28, new ECB(6, 47),
+                                               new ECB(34, 48)),
+                                  new ECBlocks(30, new ECB(46, 24),
+                                               new ECB(10, 25)),
+                                  new ECBlocks(30, new ECB(2, 15),
+                                               new ECB(64, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(37, intArray(7, 6, 28, 54, 80,
+                                  106, 132, 158),
+                                  new ECBlocks(30, new ECB(17, 122),
+                                               new ECB(4, 123)),
+                                  new ECBlocks(28, new ECB(29, 46),
+                                               new ECB(14, 47)),
+                                  new ECBlocks(30, new ECB(49, 24),
+                                               new ECB(10, 25)),
+                                  new ECBlocks(30, new ECB(24, 15),
+                                               new ECB(46, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(38, intArray(7, 6, 32, 58, 84,
+                                  110, 136, 162),
+                                  new ECBlocks(30, new ECB(4, 122),
+                                               new ECB(18, 123)),
+                                  new ECBlocks(28, new ECB(13, 46),
+                                               new ECB(32, 47)),
+                                  new ECBlocks(30, new ECB(48, 24),
+                                               new ECB(14, 25)),
+                                  new ECBlocks(30, new ECB(42, 15),
+                                               new ECB(32, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(39, intArray(7, 6, 26, 54, 82,
+                                  110, 138, 166),
+                                  new ECBlocks(30, new ECB(20, 117),
+                                               new ECB(4, 118)),
+                                  new ECBlocks(28, new ECB(40, 47),
+                                               new ECB(7, 48)),
+                                  new ECBlocks(30, new ECB(43, 24),
+                                               new ECB(22, 25)),
+                                  new ECBlocks(30, new ECB(10, 15),
+                                               new ECB(67, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(40, intArray(7, 6, 30, 58, 86,
+                                  114, 142, 170),
+                                  new ECBlocks(30, new ECB(19, 118),
+                                               new ECB(6, 119)),
+                                  new ECBlocks(28, new ECB(18, 47),
+                                               new ECB(31, 48)),
+                                  new ECBlocks(30, new ECB(34, 24),
+                                               new ECB(34, 25)),
+                                  new ECBlocks(30, new ECB(20, 15),
+                                               new ECB(61, 16)))));
+  return VERSIONS.size();
+}
+}
+}