cpp/core/src/zxing/qrcode/Version.cpp

   1 /*
   2  *  Version.cpp
   3  *  zxing
   4  *
   5  *  Created by Christian Brunschen on 14/05/2008.
   6  *  Copyright 2008 ZXing authors All rights reserved.
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <zxing/qrcode/Version.h>
  22 #include <zxing/qrcode/FormatInformation.h>
  23 #include <cstdarg>
  24 #include <limits>
  25 #include <iostream>
  26
  27 namespace zxing {
  28 namespace qrcode {
  29 using namespace std;
  30
  31 ECB::ECB(int count, int dataCodewords) :
  32     count_(count), dataCodewords_(dataCodewords) {
  33 }
  34
  35 int ECB::getCount() {
  36   return count_;
  37 }
  38
  39 int ECB::getDataCodewords() {
  40   return dataCodewords_;
  41 }
  42
  43 ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
  44     ecCodewords_(ecCodewords) {
  45   ecBlocks_.push_back(ecBlocks);
  46 }
  47
  48 ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
  49     ecCodewords_(ecCodewords) {
  50   ecBlocks_.push_back(ecBlocks1);
  51   ecBlocks_.push_back(ecBlocks2);
  52 }
  53
  54 int ECBlocks::getECCodewords() {
  55   return ecCodewords_;
  56 }
  57
  58 std::vector<ECB*>& ECBlocks::getECBlocks() {
  59   return ecBlocks_;
  60 }
  61
  62 ECBlocks::~ECBlocks() {
  63   for (size_t i = 0; i < ecBlocks_.size(); i++) {
  64     delete ecBlocks_[i];
  65   }
  66 }
  67
  68 unsigned int Version::VERSION_DECODE_INFO[] = { 0x07C94, 0x085BC, 0x09A99, 0x0A4D3, 0x0BBF6, 0x0C762, 0x0D847, 0x0E60D,
  69     0x0F928, 0x10B78, 0x1145D, 0x12A17, 0x13532, 0x149A6, 0x15683, 0x168C9, 0x177EC, 0x18EC4, 0x191E1, 0x1AFAB,
  70     0x1B08E, 0x1CC1A, 0x1D33F, 0x1ED75, 0x1F250, 0x209D5, 0x216F0, 0x228BA, 0x2379F, 0x24B0B, 0x2542E, 0x26A64,
  71     0x27541, 0x28C69
  72                                               };
  73 int Version::N_VERSION_DECODE_INFOS = 34;
  74 vector<Ref<Version> > Version::VERSIONS;
  75 static int N_VERSIONS = Version::buildVersions();
  76
  77 int Version::getVersionNumber() {
  78   return versionNumber_;
  79 }
  80
  81 valarray<int> &Version::getAlignmentPatternCenters() {
  82   return alignmentPatternCenters_;
  83 }
  84
  85 int Version::getTotalCodewords() {
  86   return totalCodewords_;
  87 }
  88
  89 int Version::getDimensionForVersion() {
  90   return 17 + 4 * versionNumber_;
  91 }
  92
  93 ECBlocks& Version::getECBlocksForLevel(ErrorCorrectionLevel &ecLevel) {
  94   return *ecBlocks_[ecLevel.ordinal()];
  95 }
  96
  97 Version *Version::getProvisionalVersionForDimension(int dimension) {
  98   if (dimension % 4 != 1) {
  99     throw ReaderException("Dimension must be 1 mod 4");
 100   }
 101   return Version::getVersionForNumber((dimension - 17) >> 2);
 102 }
 103
 104 Version *Version::getVersionForNumber(int versionNumber) {
 105   if (versionNumber < 1 || versionNumber > 40) {
 106     throw ReaderException("versionNumber must be between 1 and 40");
 107   }
 108
 109   return VERSIONS[versionNumber - 1];
 110 }
 111
 112 Version::Version(int versionNumber, valarray<int> *alignmentPatternCenters, ECBlocks *ecBlocks1, ECBlocks *ecBlocks2,
 113                  ECBlocks *ecBlocks3, ECBlocks *ecBlocks4) :
 114     versionNumber_(versionNumber), alignmentPatternCenters_(*alignmentPatternCenters), ecBlocks_(4) {
 115   ecBlocks_[0] = ecBlocks1;
 116   ecBlocks_[1] = ecBlocks2;
 117   ecBlocks_[2] = ecBlocks3;
 118   ecBlocks_[3] = ecBlocks4;
 119
 120   int total = 0;
 121   int ecCodewords = ecBlocks1->getECCodewords();
 122   vector<ECB*> &ecbArray = ecBlocks1->getECBlocks();
 123   for (size_t i = 0; i < ecbArray.size(); i++) {
 124     ECB *ecBlock = ecbArray[i];
 125     total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
 126   }
 127   totalCodewords_ = total;
 128 }
 129
 130 Version::~Version() {
 131   delete &alignmentPatternCenters_;
 132   for (size_t i = 0; i < ecBlocks_.size(); i++) {
 133     delete ecBlocks_[i];
 134   }
 135 }
 136
 137 Version *Version::decodeVersionInformation(unsigned int versionBits) {
 138   int bestDifference = numeric_limits<int>::max();
 139   size_t bestVersion = 0;
 140   for (int i = 0; i < N_VERSION_DECODE_INFOS; i++) {
 141     unsigned targetVersion = VERSION_DECODE_INFO[i];
 142     // Do the version info bits match exactly? done.
 143     if (targetVersion == versionBits) {
 144       return getVersionForNumber(i + 7);
 145     }
 146     // Otherwise see if this is the closest to a real version info bit
 147     // string we have seen so far
 148     int bitsDifference = FormatInformation::numBitsDiffering(versionBits, targetVersion);
 149     if (bitsDifference < bestDifference) {
 150       bestVersion = i + 7;
 151       bestDifference = bitsDifference;
 152     }
 153   }
 154   // We can tolerate up to 3 bits of error since no two version info codewords will
 155   // differ in less than 4 bits.
 156   if (bestDifference <= 3) {
 157     return getVersionForNumber(bestVersion);
 158   }
 159   // If we didn't find a close enough match, fail
 160   return 0;
 161 }
 162
 163 Ref<BitMatrix> Version::buildFunctionPattern() {
 164   int dimension = getDimensionForVersion();
 165   Ref<BitMatrix> functionPattern(new BitMatrix(dimension));
 166
 167
 168   // Top left finder pattern + separator + format
 169   functionPattern->setRegion(0, 0, 9, 9);
 170   // Top right finder pattern + separator + format
 171   functionPattern->setRegion(dimension - 8, 0, 8, 9);
 172   // Bottom left finder pattern + separator + format
 173   functionPattern->setRegion(0, dimension - 8, 9, 8);
 174
 175
 176   // Alignment patterns
 177   size_t max = alignmentPatternCenters_.size();
 178   for (size_t x = 0; x < max; x++) {
 179     int i = alignmentPatternCenters_[x] - 2;
 180     for (size_t y = 0; y < max; y++) {
 181       if ((x == 0 && (y == 0 || y == max - 1)) || (x == max - 1 && y == 0)) {
 182         // No alignment patterns near the three finder patterns
 183         continue;
 184       }
 185       functionPattern->setRegion(alignmentPatternCenters_[y] - 2, i, 5, 5);
 186     }
 187   }
 188
 189   // Vertical timing pattern
 190   functionPattern->setRegion(6, 9, 1, dimension - 17);
 191   // Horizontal timing pattern
 192   functionPattern->setRegion(9, 6, dimension - 17, 1);
 193
 194   if (versionNumber_ > 6) {
 195     // Version info, top right
 196     functionPattern->setRegion(dimension - 11, 0, 3, 6);
 197     // Version info, bottom left
 198     functionPattern->setRegion(0, dimension - 11, 6, 3);
 199   }
 200
 201
 202   //#ifdef DEBUG
 203   //    cout << "version " << versionNumber_ << " built function pattern:\n";
 204   //    cout << *functionPattern;
 205   //#endif
 206
 207   return functionPattern;
 208 }
 209
 210 static valarray<int> *intArray(size_t n...) {
 211   va_list ap;
 212   va_start(ap, n);
 213   valarray<int> *result = new valarray<int>(n);
 214   for (size_t i = 0; i < n; i++) {
 215     (*result)[i] = va_arg(ap, int);
 216   }
 217   va_end(ap);
 218   return result;
 219 }
 220
 221 int Version::buildVersions() {
 222   VERSIONS.push_back(Ref<Version>(new Version(1, intArray(0),
 223                                   new ECBlocks(7, new ECB(1, 19)),
 224                                   new ECBlocks(10, new ECB(1, 16)),
 225                                   new ECBlocks(13, new ECB(1, 13)),
 226                                   new ECBlocks(17, new ECB(1, 9)))));
 227   VERSIONS.push_back(Ref<Version>(new Version(2, intArray(2, 6, 18),
 228                                   new ECBlocks(10, new ECB(1, 34)),
 229                                   new ECBlocks(16, new ECB(1, 28)),
 230                                   new ECBlocks(22, new ECB(1, 22)),
 231                                   new ECBlocks(28, new ECB(1, 16)))));
 232   VERSIONS.push_back(Ref<Version>(new Version(3, intArray(2, 6, 22),
 233                                   new ECBlocks(15, new ECB(1, 55)),
 234                                   new ECBlocks(26, new ECB(1, 44)),
 235                                   new ECBlocks(18, new ECB(2, 17)),
 236                                   new ECBlocks(22, new ECB(2, 13)))));
 237   VERSIONS.push_back(Ref<Version>(new Version(4, intArray(2, 6, 26),
 238                                   new ECBlocks(20, new ECB(1, 80)),
 239                                   new ECBlocks(18, new ECB(2, 32)),
 240                                   new ECBlocks(26, new ECB(2, 24)),
 241                                   new ECBlocks(16, new ECB(4, 9)))));
 242   VERSIONS.push_back(Ref<Version>(new Version(5, intArray(2, 6, 30),
 243                                   new ECBlocks(26, new ECB(1, 108)),
 244                                   new ECBlocks(24, new ECB(2, 43)),
 245                                   new ECBlocks(18, new ECB(2, 15),
 246                                                new ECB(2, 16)),
 247                                   new ECBlocks(22, new ECB(2, 11),
 248                                                new ECB(2, 12)))));
 249   VERSIONS.push_back(Ref<Version>(new Version(6, intArray(2, 6, 34),
 250                                   new ECBlocks(18, new ECB(2, 68)),
 251                                   new ECBlocks(16, new ECB(4, 27)),
 252                                   new ECBlocks(24, new ECB(4, 19)),
 253                                   new ECBlocks(28, new ECB(4, 15)))));
 254   VERSIONS.push_back(Ref<Version>(new Version(7, intArray(3, 6, 22, 38),
 255                                   new ECBlocks(20, new ECB(2, 78)),
 256                                   new ECBlocks(18, new ECB(4, 31)),
 257                                   new ECBlocks(18, new ECB(2, 14),
 258                                                new ECB(4, 15)),
 259                                   new ECBlocks(26, new ECB(4, 13),
 260                                                new ECB(1, 14)))));
 261   VERSIONS.push_back(Ref<Version>(new Version(8, intArray(3, 6, 24, 42),
 262                                   new ECBlocks(24, new ECB(2, 97)),
 263                                   new ECBlocks(22, new ECB(2, 38),
 264                                                new ECB(2, 39)),
 265                                   new ECBlocks(22, new ECB(4, 18),
 266                                                new ECB(2, 19)),
 267                                   new ECBlocks(26, new ECB(4, 14),
 268                                                new ECB(2, 15)))));
 269   VERSIONS.push_back(Ref<Version>(new Version(9, intArray(3, 6, 26, 46),
 270                                   new ECBlocks(30, new ECB(2, 116)),
 271                                   new ECBlocks(22, new ECB(3, 36),
 272                                                new ECB(2, 37)),
 273                                   new ECBlocks(20, new ECB(4, 16),
 274                                                new ECB(4, 17)),
 275                                   new ECBlocks(24, new ECB(4, 12),
 276                                                new ECB(4, 13)))));
 277   VERSIONS.push_back(Ref<Version>(new Version(10, intArray(3, 6, 28, 50),
 278                                   new ECBlocks(18, new ECB(2, 68),
 279                                                new ECB(2, 69)),
 280                                   new ECBlocks(26, new ECB(4, 43),
 281                                                new ECB(1, 44)),
 282                                   new ECBlocks(24, new ECB(6, 19),
 283                                                new ECB(2, 20)),
 284                                   new ECBlocks(28, new ECB(6, 15),
 285                                                new ECB(2, 16)))));
 286   VERSIONS.push_back(Ref<Version>(new Version(11, intArray(3, 6, 30, 54),
 287                                   new ECBlocks(20, new ECB(4, 81)),
 288                                   new ECBlocks(30, new ECB(1, 50),
 289                                                new ECB(4, 51)),
 290                                   new ECBlocks(28, new ECB(4, 22),
 291                                                new ECB(4, 23)),
 292                                   new ECBlocks(24, new ECB(3, 12),
 293                                                new ECB(8, 13)))));
 294   VERSIONS.push_back(Ref<Version>(new Version(12, intArray(3, 6, 32, 58),
 295                                   new ECBlocks(24, new ECB(2, 92),
 296                                                new ECB(2, 93)),
 297                                   new ECBlocks(22, new ECB(6, 36),
 298                                                new ECB(2, 37)),
 299                                   new ECBlocks(26, new ECB(4, 20),
 300                                                new ECB(6, 21)),
 301                                   new ECBlocks(28, new ECB(7, 14),
 302                                                new ECB(4, 15)))));
 303   VERSIONS.push_back(Ref<Version>(new Version(13, intArray(3, 6, 34, 62),
 304                                   new ECBlocks(26, new ECB(4, 107)),
 305                                   new ECBlocks(22, new ECB(8, 37),
 306                                                new ECB(1, 38)),
 307                                   new ECBlocks(24, new ECB(8, 20),
 308                                                new ECB(4, 21)),
 309                                   new ECBlocks(22, new ECB(12, 11),
 310                                                new ECB(4, 12)))));
 311   VERSIONS.push_back(Ref<Version>(new Version(14, intArray(4, 6, 26, 46, 66),
 312                                   new ECBlocks(30, new ECB(3, 115),
 313                                                new ECB(1, 116)),
 314                                   new ECBlocks(24, new ECB(4, 40),
 315                                                new ECB(5, 41)),
 316                                   new ECBlocks(20, new ECB(11, 16),
 317                                                new ECB(5, 17)),
 318                                   new ECBlocks(24, new ECB(11, 12),
 319                                                new ECB(5, 13)))));
 320   VERSIONS.push_back(Ref<Version>(new Version(15, intArray(4, 6, 26, 48, 70),
 321                                   new ECBlocks(22, new ECB(5, 87),
 322                                                new ECB(1, 88)),
 323                                   new ECBlocks(24, new ECB(5, 41),
 324                                                new ECB(5, 42)),
 325                                   new ECBlocks(30, new ECB(5, 24),
 326                                                new ECB(7, 25)),
 327                                   new ECBlocks(24, new ECB(11, 12),
 328                                                new ECB(7, 13)))));
 329   VERSIONS.push_back(Ref<Version>(new Version(16, intArray(4, 6, 26, 50, 74),
 330                                   new ECBlocks(24, new ECB(5, 98),
 331                                                new ECB(1, 99)),
 332                                   new ECBlocks(28, new ECB(7, 45),
 333                                                new ECB(3, 46)),
 334                                   new ECBlocks(24, new ECB(15, 19),
 335                                                new ECB(2, 20)),
 336                                   new ECBlocks(30, new ECB(3, 15),
 337                                                new ECB(13, 16)))));
 338   VERSIONS.push_back(Ref<Version>(new Version(17, intArray(4, 6, 30, 54, 78),
 339                                   new ECBlocks(28, new ECB(1, 107),
 340                                                new ECB(5, 108)),
 341                                   new ECBlocks(28, new ECB(10, 46),
 342                                                new ECB(1, 47)),
 343                                   new ECBlocks(28, new ECB(1, 22),
 344                                                new ECB(15, 23)),
 345                                   new ECBlocks(28, new ECB(2, 14),
 346                                                new ECB(17, 15)))));
 347   VERSIONS.push_back(Ref<Version>(new Version(18, intArray(4, 6, 30, 56, 82),
 348                                   new ECBlocks(30, new ECB(5, 120),
 349                                                new ECB(1, 121)),
 350                                   new ECBlocks(26, new ECB(9, 43),
 351                                                new ECB(4, 44)),
 352                                   new ECBlocks(28, new ECB(17, 22),
 353                                                new ECB(1, 23)),
 354                                   new ECBlocks(28, new ECB(2, 14),
 355                                                new ECB(19, 15)))));
 356   VERSIONS.push_back(Ref<Version>(new Version(19, intArray(4, 6, 30, 58, 86),
 357                                   new ECBlocks(28, new ECB(3, 113),
 358                                                new ECB(4, 114)),
 359                                   new ECBlocks(26, new ECB(3, 44),
 360                                                new ECB(11, 45)),
 361                                   new ECBlocks(26, new ECB(17, 21),
 362                                                new ECB(4, 22)),
 363                                   new ECBlocks(26, new ECB(9, 13),
 364                                                new ECB(16, 14)))));
 365   VERSIONS.push_back(Ref<Version>(new Version(20, intArray(4, 6, 34, 62, 90),
 366                                   new ECBlocks(28, new ECB(3, 107),
 367                                                new ECB(5, 108)),
 368                                   new ECBlocks(26, new ECB(3, 41),
 369                                                new ECB(13, 42)),
 370                                   new ECBlocks(30, new ECB(15, 24),
 371                                                new ECB(5, 25)),
 372                                   new ECBlocks(28, new ECB(15, 15),
 373                                                new ECB(10, 16)))));
 374   VERSIONS.push_back(Ref<Version>(new Version(21, intArray(5, 6, 28, 50, 72, 94),
 375                                   new ECBlocks(28, new ECB(4, 116),
 376                                                new ECB(4, 117)),
 377                                   new ECBlocks(26, new ECB(17, 42)),
 378                                   new ECBlocks(28, new ECB(17, 22),
 379                                                new ECB(6, 23)),
 380                                   new ECBlocks(30, new ECB(19, 16),
 381                                                new ECB(6, 17)))));
 382   VERSIONS.push_back(Ref<Version>(new Version(22, intArray(5, 6, 26, 50, 74, 98),
 383                                   new ECBlocks(28, new ECB(2, 111),
 384                                                new ECB(7, 112)),
 385                                   new ECBlocks(28, new ECB(17, 46)),
 386                                   new ECBlocks(30, new ECB(7, 24),
 387                                                new ECB(16, 25)),
 388                                   new ECBlocks(24, new ECB(34, 13)))));
 389   VERSIONS.push_back(Ref<Version>(new Version(23, intArray(5, 6, 30, 54, 74, 102),
 390                                   new ECBlocks(30, new ECB(4, 121),
 391                                                new ECB(5, 122)),
 392                                   new ECBlocks(28, new ECB(4, 47),
 393                                                new ECB(14, 48)),
 394                                   new ECBlocks(30, new ECB(11, 24),
 395                                                new ECB(14, 25)),
 396                                   new ECBlocks(30, new ECB(16, 15),
 397                                                new ECB(14, 16)))));
 398   VERSIONS.push_back(Ref<Version>(new Version(24, intArray(5, 6, 28, 54, 80, 106),
 399                                   new ECBlocks(30, new ECB(6, 117),
 400                                                new ECB(4, 118)),
 401                                   new ECBlocks(28, new ECB(6, 45),
 402                                                new ECB(14, 46)),
 403                                   new ECBlocks(30, new ECB(11, 24),
 404                                                new ECB(16, 25)),
 405                                   new ECBlocks(30, new ECB(30, 16),
 406                                                new ECB(2, 17)))));
 407   VERSIONS.push_back(Ref<Version>(new Version(25, intArray(5, 6, 32, 58, 84, 110),
 408                                   new ECBlocks(26, new ECB(8, 106),
 409                                                new ECB(4, 107)),
 410                                   new ECBlocks(28, new ECB(8, 47),
 411                                                new ECB(13, 48)),
 412                                   new ECBlocks(30, new ECB(7, 24),
 413                                                new ECB(22, 25)),
 414                                   new ECBlocks(30, new ECB(22, 15),
 415                                                new ECB(13, 16)))));
 416   VERSIONS.push_back(Ref<Version>(new Version(26, intArray(5, 6, 30, 58, 86, 114),
 417                                   new ECBlocks(28, new ECB(10, 114),
 418                                                new ECB(2, 115)),
 419                                   new ECBlocks(28, new ECB(19, 46),
 420                                                new ECB(4, 47)),
 421                                   new ECBlocks(28, new ECB(28, 22),
 422                                                new ECB(6, 23)),
 423                                   new ECBlocks(30, new ECB(33, 16),
 424                                                new ECB(4, 17)))));
 425   VERSIONS.push_back(Ref<Version>(new Version(27, intArray(5, 6, 34, 62, 90, 118),
 426                                   new ECBlocks(30, new ECB(8, 122),
 427                                                new ECB(4, 123)),
 428                                   new ECBlocks(28, new ECB(22, 45),
 429                                                new ECB(3, 46)),
 430                                   new ECBlocks(30, new ECB(8, 23),
 431                                                new ECB(26, 24)),
 432                                   new ECBlocks(30, new ECB(12, 15),
 433                                                new ECB(28, 16)))));
 434   VERSIONS.push_back(Ref<Version>(new Version(28, intArray(6, 6, 26, 50, 74, 98, 122),
 435                                   new ECBlocks(30, new ECB(3, 117),
 436                                                new ECB(10, 118)),
 437                                   new ECBlocks(28, new ECB(3, 45),
 438                                                new ECB(23, 46)),
 439                                   new ECBlocks(30, new ECB(4, 24),
 440                                                new ECB(31, 25)),
 441                                   new ECBlocks(30, new ECB(11, 15),
 442                                                new ECB(31, 16)))));
 443   VERSIONS.push_back(Ref<Version>(new Version(29, intArray(6, 6, 30, 54, 78, 102, 126),
 444                                   new ECBlocks(30, new ECB(7, 116),
 445                                                new ECB(7, 117)),
 446                                   new ECBlocks(28, new ECB(21, 45),
 447                                                new ECB(7, 46)),
 448                                   new ECBlocks(30, new ECB(1, 23),
 449                                                new ECB(37, 24)),
 450                                   new ECBlocks(30, new ECB(19, 15),
 451                                                new ECB(26, 16)))));
 452   VERSIONS.push_back(Ref<Version>(new Version(30, intArray(6, 6, 26, 52, 78, 104, 130),
 453                                   new ECBlocks(30, new ECB(5, 115),
 454                                                new ECB(10, 116)),
 455                                   new ECBlocks(28, new ECB(19, 47),
 456                                                new ECB(10, 48)),
 457                                   new ECBlocks(30, new ECB(15, 24),
 458                                                new ECB(25, 25)),
 459                                   new ECBlocks(30, new ECB(23, 15),
 460                                                new ECB(25, 16)))));
 461   VERSIONS.push_back(Ref<Version>(new Version(31, intArray(6, 6, 30, 56, 82, 108, 134),
 462                                   new ECBlocks(30, new ECB(13, 115),
 463                                                new ECB(3, 116)),
 464                                   new ECBlocks(28, new ECB(2, 46),
 465                                                new ECB(29, 47)),
 466                                   new ECBlocks(30, new ECB(42, 24),
 467                                                new ECB(1, 25)),
 468                                   new ECBlocks(30, new ECB(23, 15),
 469                                                new ECB(28, 16)))));
 470   VERSIONS.push_back(Ref<Version>(new Version(32, intArray(6, 6, 34, 60, 86, 112, 138),
 471                                   new ECBlocks(30, new ECB(17, 115)),
 472                                   new ECBlocks(28, new ECB(10, 46),
 473                                                new ECB(23, 47)),
 474                                   new ECBlocks(30, new ECB(10, 24),
 475                                                new ECB(35, 25)),
 476                                   new ECBlocks(30, new ECB(19, 15),
 477                                                new ECB(35, 16)))));
 478   VERSIONS.push_back(Ref<Version>(new Version(33, intArray(6, 6, 30, 58, 86, 114, 142),
 479                                   new ECBlocks(30, new ECB(17, 115),
 480                                                new ECB(1, 116)),
 481                                   new ECBlocks(28, new ECB(14, 46),
 482                                                new ECB(21, 47)),
 483                                   new ECBlocks(30, new ECB(29, 24),
 484                                                new ECB(19, 25)),
 485                                   new ECBlocks(30, new ECB(11, 15),
 486                                                new ECB(46, 16)))));
 487   VERSIONS.push_back(Ref<Version>(new Version(34, intArray(6, 6, 34, 62, 90, 118, 146),
 488                                   new ECBlocks(30, new ECB(13, 115),
 489                                                new ECB(6, 116)),
 490                                   new ECBlocks(28, new ECB(14, 46),
 491                                                new ECB(23, 47)),
 492                                   new ECBlocks(30, new ECB(44, 24),
 493                                                new ECB(7, 25)),
 494                                   new ECBlocks(30, new ECB(59, 16),
 495                                                new ECB(1, 17)))));
 496   VERSIONS.push_back(Ref<Version>(new Version(35, intArray(7, 6, 30, 54, 78,
 497                                   102, 126, 150),
 498                                   new ECBlocks(30, new ECB(12, 121),
 499                                                new ECB(7, 122)),
 500                                   new ECBlocks(28, new ECB(12, 47),
 501                                                new ECB(26, 48)),
 502                                   new ECBlocks(30, new ECB(39, 24),
 503                                                new ECB(14, 25)),
 504                                   new ECBlocks(30, new ECB(22, 15),
 505                                                new ECB(41, 16)))));
 506   VERSIONS.push_back(Ref<Version>(new Version(36, intArray(7, 6, 24, 50, 76,
 507                                   102, 128, 154),
 508                                   new ECBlocks(30, new ECB(6, 121),
 509                                                new ECB(14, 122)),
 510                                   new ECBlocks(28, new ECB(6, 47),
 511                                                new ECB(34, 48)),
 512                                   new ECBlocks(30, new ECB(46, 24),
 513                                                new ECB(10, 25)),
 514                                   new ECBlocks(30, new ECB(2, 15),
 515                                                new ECB(64, 16)))));
 516   VERSIONS.push_back(Ref<Version>(new Version(37, intArray(7, 6, 28, 54, 80,
 517                                   106, 132, 158),
 518                                   new ECBlocks(30, new ECB(17, 122),
 519                                                new ECB(4, 123)),
 520                                   new ECBlocks(28, new ECB(29, 46),
 521                                                new ECB(14, 47)),
 522                                   new ECBlocks(30, new ECB(49, 24),
 523                                                new ECB(10, 25)),
 524                                   new ECBlocks(30, new ECB(24, 15),
 525                                                new ECB(46, 16)))));
 526   VERSIONS.push_back(Ref<Version>(new Version(38, intArray(7, 6, 32, 58, 84,
 527                                   110, 136, 162),
 528                                   new ECBlocks(30, new ECB(4, 122),
 529                                                new ECB(18, 123)),
 530                                   new ECBlocks(28, new ECB(13, 46),
 531                                                new ECB(32, 47)),
 532                                   new ECBlocks(30, new ECB(48, 24),
 533                                                new ECB(14, 25)),
 534                                   new ECBlocks(30, new ECB(42, 15),
 535                                                new ECB(32, 16)))));
 536   VERSIONS.push_back(Ref<Version>(new Version(39, intArray(7, 6, 26, 54, 82,
 537                                   110, 138, 166),
 538                                   new ECBlocks(30, new ECB(20, 117),
 539                                                new ECB(4, 118)),
 540                                   new ECBlocks(28, new ECB(40, 47),
 541                                                new ECB(7, 48)),
 542                                   new ECBlocks(30, new ECB(43, 24),
 543                                                new ECB(22, 25)),
 544                                   new ECBlocks(30, new ECB(10, 15),
 545                                                new ECB(67, 16)))));
 546   VERSIONS.push_back(Ref<Version>(new Version(40, intArray(7, 6, 30, 58, 86,
 547                                   114, 142, 170),
 548                                   new ECBlocks(30, new ECB(19, 118),
 549                                                new ECB(6, 119)),
 550                                   new ECBlocks(28, new ECB(18, 47),
 551                                                new ECB(31, 48)),
 552                                   new ECBlocks(30, new ECB(34, 24),
 553                                                new ECB(34, 25)),
 554                                   new ECBlocks(30, new ECB(20, 15),
 555                                                new ECB(61, 16)))));
 556   return VERSIONS.size();
 557 }
 558 }
 559 }