// Embed position adjustment patterns if need be.
 private static void maybeEmbedPositionAdjustmentPatterns(int version, ByteMatrix matrix)
 {
     if (version < 2) {  // The patterns appear if version >= 2
       return;
     }
     int index = version - 1;
     int[] coordinates = POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[index];
     int numCoordinates = POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE[index].Length;
     for (int i = 0; i < numCoordinates; ++i) {
       for (int j = 0; j < numCoordinates; ++j) {
         int y = coordinates[i];
         int x = coordinates[j];
         if (x == -1 || y == -1) {
           continue;
         }
         // If the cell is unset, we embed the position adjustment pattern here.
         if (isEmpty(matrix.get(y, x))) {
           // -2 is necessary since the x/y coordinates point to the center of the pattern, not the
           // left top corner.
           embedPositionAdjustmentPattern(x - 2, y - 2, matrix);
         }
       }
     }
 }
 private static void embedTimingPatterns(ByteMatrix matrix)
 {
     // -8 is for skipping position detection patterns (size 7), and two horizontal/vertical
     // separation patterns (size 1). Thus, 8 = 7 + 1.
     for (int i = 8; i < matrix.width() - 8; ++i) {
       int bit = (i + 1) % 2;
       // Horizontal line.
       if (!isValidValue(matrix.get(6, i))) {
         throw new WriterException();
       }
       if (isEmpty(matrix.get(6, i))) {
         matrix.set(6, i, bit);
       }
       // Vertical line.
       if (!isValidValue(matrix.get(i, 6))) {
         throw new WriterException();
       }
       if (isEmpty(matrix.get(i, 6))) {
         matrix.set(i, 6, bit);
       }
     }
 }
 private static void embedVerticalSeparationPattern(int xStart, int yStart,ByteMatrix matrix)
 {
     // We know the width and height.
     if (VERTICAL_SEPARATION_PATTERN[0].Length != 1 || VERTICAL_SEPARATION_PATTERN.Length != 7) {
       throw new WriterException("Bad vertical separation pattern");
     }
     for (int y = 0; y < 7; ++y) {
       if (!isEmpty(matrix.get(yStart + y, xStart))) {
         throw new WriterException();
       }
       matrix.set(yStart + y, xStart, VERTICAL_SEPARATION_PATTERN[y][0]);
     }
 }
 private static void embedPositionDetectionPattern(int xStart, int yStart,ByteMatrix matrix)
 {
     // We know the width and height.
     if (POSITION_DETECTION_PATTERN[0].Length != 7 || POSITION_DETECTION_PATTERN.Length != 7) {
       throw new WriterException("Bad position detection pattern");
     }
     for (int y = 0; y < 7; ++y) {
       for (int x = 0; x < 7; ++x) {
         if (!isEmpty(matrix.get(yStart + y, xStart + x))) {
           throw new WriterException();
         }
         matrix.set(yStart + y, xStart + x, POSITION_DETECTION_PATTERN[y][x]);
       }
     }
 }
 // Note that we cannot unify the function with embedPositionDetectionPattern() despite they are
 // almost identical, since we cannot write a function that takes 2D arrays in different sizes in
 // C/C++. We should live with the fact.
 private static void embedPositionAdjustmentPattern(int xStart, int yStart,ByteMatrix matrix)
 {
     // We know the width and height.
     if (POSITION_ADJUSTMENT_PATTERN[0].Length != 5 || POSITION_ADJUSTMENT_PATTERN.Length != 5) {
       throw new WriterException("Bad position adjustment");
     }
     for (int y = 0; y < 5; ++y) {
       for (int x = 0; x < 5; ++x) {
         if (!isEmpty(matrix.get(yStart + y, xStart + x))) {
           throw new WriterException();
         }
         matrix.set(yStart + y, xStart + x, POSITION_ADJUSTMENT_PATTERN[y][x]);
       }
     }
 }
 private static void embedHorizontalSeparationPattern(int xStart, int yStart,ByteMatrix matrix)
 {
     // We know the width and height.
     if (HORIZONTAL_SEPARATION_PATTERN[0].Length != 8 || HORIZONTAL_SEPARATION_PATTERN.Length != 1) {
       throw new WriterException("Bad horizontal separation pattern");
     }
     for (int x = 0; x < 8; ++x) {
       if (!isEmpty(matrix.get(yStart, xStart + x))) {
         throw new WriterException();
       }
       matrix.set(yStart, xStart + x, HORIZONTAL_SEPARATION_PATTERN[0][x]);
     }
 }
 // Embed the lonely dark dot at left bottom corner. JISX0510:2004 (p.46)
 private static void embedDarkDotAtLeftBottomCorner(ByteMatrix matrix)
 {
     if (matrix.get(matrix.height() - 8, 8) == 0) {
       throw new WriterException();
     }
     matrix.set(matrix.height() - 8, 8, 1);
 }
        // Embed "dataBits" using "getMaskPattern". On success, modify the matrix and return true.
        // For debugging purposes, it skips masking process if "getMaskPattern" is -1.
        // See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
        public static void embedDataBits(BitVector dataBits, int maskPattern, ByteMatrix matrix)
        {
            int bitIndex = 0;
            int direction = -1;
            // Start from the right bottom cell.
            int x = matrix.width() - 1;
            int y = matrix.height() - 1;
            while (x > 0) {
              // Skip the vertical timing pattern.
              if (x == 6) {
                x -= 1;
              }
              while (y >= 0 && y < matrix.height()) {
                for (int i = 0; i < 2; ++i) {
                  int xx = x - i;
                  // Skip the cell if it's not empty.
                  if (!isEmpty(matrix.get(y, xx))) {
                    continue;
                  }
                  int bit;
                  if (bitIndex < dataBits.size()) {
                    bit = dataBits.at(bitIndex);
                    ++bitIndex;
                  } else {
                    // Padding bit. If there is no bit left, we'll fill the left cells with 0, as described
                    // in 8.4.9 of JISX0510:2004 (p. 24).
                    bit = 0;
                  }

                  // Skip masking if mask_pattern is -1.
                  if (maskPattern != -1) {
                    int mask = MaskUtil.getDataMaskBit(maskPattern, xx, y);
                    bit ^= mask;
                  }
                  matrix.set(y, xx, bit);
                }
                y += direction;
              }
              direction = -direction;  // Reverse the direction.
              y += direction;
              x -= 2;  // Move to the left.
            }
            // All bits should be consumed.
            if (bitIndex != dataBits.size()) {
              throw new WriterException("Not all bits consumed: " + bitIndex + '/' + dataBits.size());
            }
        }