protected static void recordPatternInReverse(BitArray row, int start, int[] counters)
    throws NotFoundException {
  // This could be more efficient I guess
  int numTransitionsLeft = counters.length;
  boolean last = row.get(start);
  while (start > 0 && numTransitionsLeft >= 0) {
    if (row.get(--start) != last) {
      numTransitionsLeft--;
      last = !last;
    }
  }
  if (numTransitionsLeft >= 0) {
    throw NotFoundException.getNotFoundInstance();
  }
  recordPattern(row, start + 1, counters);
}
 

/**
 * Attempts to decode a single UPC/EAN-encoded digit.
 *
 * @param row row of black/white values to decode
 * @param counters the counts of runs of observed black/white/black/... values
 * @param rowOffset horizontal offset to start decoding from
 * @param patterns the set of patterns to use to decode -- sometimes different encodings
 * for the digits 0-9 are used, and this indicates the encodings for 0 to 9 that should
 * be used
 * @return horizontal offset of first pixel beyond the decoded digit
 * @throws NotFoundException if digit cannot be decoded
 */
static int decodeDigit(BitArray row, int[] counters, int rowOffset, int[][] patterns)
    throws NotFoundException {
  recordPattern(row, rowOffset, counters);
  float bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
  int bestMatch = -1;
  int max = patterns.length;
  for (int i = 0; i < max; i++) {
    int[] pattern = patterns[i];
    float variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
    if (variance < bestVariance) {
      bestVariance = variance;
      bestMatch = i;
    }
  }
  if (bestMatch >= 0) {
    return bestMatch;
  } else {
    throw NotFoundException.getNotFoundInstance();
  }
}
 

Result decodeRow(int rowNumber, BitArray row, int[] extensionStartRange) throws NotFoundException {

    StringBuilder result = decodeRowStringBuffer;
    result.setLength(0);
    int end = decodeMiddle(row, extensionStartRange, result);

    String resultString = result.toString();
    Map<ResultMetadataType,Object> extensionData = parseExtensionString(resultString);

    Result extensionResult =
        new Result(resultString,
                   null,
                   new ResultPoint[] {
                       new ResultPoint((extensionStartRange[0] + extensionStartRange[1]) / 2.0f, (float) rowNumber),
                       new ResultPoint((float) end, (float) rowNumber),
                   },
                   BarcodeFormat.UPC_EAN_EXTENSION);
    if (extensionData != null) {
      extensionResult.putAllMetadata(extensionData);
    }
    return extensionResult;
  }
 

static int[] findStartGuardPattern(BitArray row) throws NotFoundException {
	boolean foundStart = false;
	int[] startRange = null;
	int nextStart = 0;
	int[] counters = new int[START_END_PATTERN.length];
	while (!foundStart) {
		Arrays.fill(counters, 0, START_END_PATTERN.length, 0);
		startRange = findGuardPattern(row, nextStart, false, START_END_PATTERN, counters);
		int start = startRange[0];
		nextStart = startRange[1];
		// Make sure there is a quiet zone at least as big as the start
		// pattern before the barcode.
		// If this check would run off the left edge of the image, do not
		// accept this barcode,
		// as it is very likely to be a false positive.
		int quietStart = start - (nextStart - start);
		if (quietStart >= 0) {
			foundStart = row.isRange(quietStart, start, false);
		}
	}
	return startRange;
}
 

Result decodeRow(int rowNumber, BitArray row, int[] extensionStartRange) throws NotFoundException {

    StringBuilder result = decodeRowStringBuffer;
    result.setLength(0);
    int end = decodeMiddle(row, extensionStartRange, result);

    String resultString = result.toString();
    Map<ResultMetadataType,Object> extensionData = parseExtensionString(resultString);

    Result extensionResult =
        new Result(resultString,
                   null,
                   new ResultPoint[] {
                       new ResultPoint((extensionStartRange[0] + extensionStartRange[1]) / 2.0f, rowNumber),
                       new ResultPoint(end, rowNumber),
                   },
                   BarcodeFormat.UPC_EAN_EXTENSION);
    if (extensionData != null) {
      extensionResult.putAllMetadata(extensionData);
    }
    return extensionResult;
  }
 

static void appendKanjiBytes(String content, BitArray bits) throws WriterException {
  byte[] bytes;
  try {
    bytes = content.getBytes("Shift_JIS");
  } catch (UnsupportedEncodingException uee) {
    throw new WriterException(uee);
  }
  int length = bytes.length;
  for (int i = 0; i < length; i += 2) {
    int byte1 = bytes[i] & 0xFF;
    int byte2 = bytes[i + 1] & 0xFF;
    int code = (byte1 << 8) | byte2;
    int subtracted = -1;
    if (code >= 0x8140 && code <= 0x9ffc) {
      subtracted = code - 0x8140;
    } else if (code >= 0xe040 && code <= 0xebbf) {
      subtracted = code - 0xc140;
    }
    if (subtracted == -1) {
      throw new WriterException("Invalid byte sequence");
    }
    int encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff);
    bits.appendBits(encoded, 13);
  }
}
 

static int[] findStartGuardPattern(BitArray row) throws NotFoundException {
  boolean foundStart = false;
  int[] startRange = null;
  int nextStart = 0;
  int[] counters = new int[START_END_PATTERN.length];
  while (!foundStart) {
    Arrays.fill(counters, 0, START_END_PATTERN.length, 0);
    startRange = findGuardPattern(row, nextStart, false, START_END_PATTERN, counters);
    int start = startRange[0];
    nextStart = startRange[1];
    // Make sure there is a quiet zone at least as big as the start pattern before the barcode.
    // If this check would run off the left edge of the image, do not accept this barcode,
    // as it is very likely to be a false positive.
    int quietStart = start - (nextStart - start);
    if (quietStart >= 0) {
      foundStart = row.isRange(quietStart, start, false);
    }
  }
  return startRange;
}
 

static void appendAlphanumericBytes(CharSequence content, BitArray bits) throws WriterException {
  int length = content.length();
  int i = 0;
  while (i < length) {
    int code1 = getAlphanumericCode(content.charAt(i));
    if (code1 == -1) {
      throw new WriterException();
    }
    if (i + 1 < length) {
      int code2 = getAlphanumericCode(content.charAt(i + 1));
      if (code2 == -1) {
        throw new WriterException();
      }
      // Encode two alphanumeric letters in 11 bits.
      bits.appendBits(code1 * 45 + code2, 11);
      i += 2;
    } else {
      // Encode one alphanumeric letter in six bits.
      bits.appendBits(code1, 6);
      i++;
    }
  }
}
 

Result decodeRow(int rowNumber, BitArray row, int[] extensionStartRange) throws NotFoundException {

    StringBuilder result = decodeRowStringBuffer;
    result.setLength(0);
    int end = decodeMiddle(row, extensionStartRange, result);

    String resultString = result.toString();
    Map<ResultMetadataType,Object> extensionData = parseExtensionString(resultString);

    Result extensionResult =
        new Result(resultString,
                   null,
                   new ResultPoint[] {
                       new ResultPoint((extensionStartRange[0] + extensionStartRange[1]) / 2.0f, (float) rowNumber),
                       new ResultPoint((float) end, (float) rowNumber),
                   },
                   BarcodeFormat.UPC_EAN_EXTENSION);
    if (extensionData != null) {
      extensionResult.putAllMetadata(extensionData);
    }
    return extensionResult;
  }
 

static void appendKanjiBytes(String content, BitArray bits) throws WriterException {
  byte[] bytes;
  try {
    bytes = content.getBytes("Shift_JIS");
  } catch (UnsupportedEncodingException uee) {
    throw new WriterException(uee);
  }
  int length = bytes.length;
  for (int i = 0; i < length; i += 2) {
    int byte1 = bytes[i] & 0xFF;
    int byte2 = bytes[i + 1] & 0xFF;
    int code = (byte1 << 8) | byte2;
    int subtracted = -1;
    if (code >= 0x8140 && code <= 0x9ffc) {
      subtracted = code - 0x8140;
    } else if (code >= 0xe040 && code <= 0xebbf) {
      subtracted = code - 0xc140;
    }
    if (subtracted == -1) {
      throw new WriterException("Invalid byte sequence");
    }
    int encoded = ((subtracted >> 8) * 0xc0) + (subtracted & 0xff);
    bits.appendBits(encoded, 13);
  }
}
 

/**
 * Append "bytes" in "mode" mode (encoding) into "bits". On success, store the result in "bits".
 */
static void appendBytes(String content,
                        Mode mode,
                        BitArray bits,
                        String encoding) throws WriterException {
  switch (mode) {
    case NUMERIC:
      appendNumericBytes(content, bits);
      break;
    case ALPHANUMERIC:
      appendAlphanumericBytes(content, bits);
      break;
    case BYTE:
      append8BitBytes(content, bits, encoding);
      break;
    case KANJI:
      appendKanjiBytes(content, bits);
      break;
    default:
      throw new WriterException("Invalid mode: " + mode);
  }
}
 

Result decodeRow(int rowNumber, BitArray row, int[] extensionStartRange) throws NotFoundException {

    StringBuilder result = decodeRowStringBuffer;
    result.setLength(0);
    int end = decodeMiddle(row, extensionStartRange, result);

    String resultString = result.toString();
    Map<ResultMetadataType,Object> extensionData = parseExtensionString(resultString);

    Result extensionResult =
        new Result(resultString,
                   null,
                   new ResultPoint[] {
                       new ResultPoint((extensionStartRange[0] + extensionStartRange[1]) / 2.0f, (float) rowNumber),
                       new ResultPoint((float) end, (float) rowNumber),
                   },
                   BarcodeFormat.UPC_EAN_EXTENSION);
    if (extensionData != null) {
      extensionResult.putAllMetadata(extensionData);
    }
    return extensionResult;
  }
 

private FinderPattern parseFoundFinderPattern(BitArray row, int rowNumber, boolean right, int[] startEnd)
    throws NotFoundException {
  // Actually we found elements 2-5
  boolean firstIsBlack = row.get(startEnd[0]);
  int firstElementStart = startEnd[0] - 1;
  // Locate element 1
  while (firstElementStart >= 0 && firstIsBlack ^ row.get(firstElementStart)) {
    firstElementStart--;
  }
  firstElementStart++;
  int firstCounter = startEnd[0] - firstElementStart;
  // Make 'counters' hold 1-4
  int[] counters = getDecodeFinderCounters();
  System.arraycopy(counters, 0, counters, 1, counters.length - 1);
  counters[0] = firstCounter;
  int value = parseFinderValue(counters, FINDER_PATTERNS);
  int start = firstElementStart;
  int end = startEnd[1];
  if (right) {
    // row is actually reversed
    start = row.getSize() - 1 - start;
    end = row.getSize() - 1 - end;
  }
  return new FinderPattern(value, new int[] {firstElementStart, startEnd[1]}, start, end, rowNumber);
}
 

/**
 * The start & end patterns must be pre/post fixed by a quiet zone. This
 * zone must be at least 10 times the width of a narrow line.  Scan back until
 * we either get to the start of the barcode or match the necessary number of
 * quiet zone pixels.
 *
 * Note: Its assumed the row is reversed when using this method to find
 * quiet zone after the end pattern.
 *
 * ref: http://www.barcode-1.net/i25code.html
 *
 * @param row bit array representing the scanned barcode.
 * @param startPattern index into row of the start or end pattern.
 * @throws NotFoundException if the quiet zone cannot be found, a ReaderException is thrown.
 */
private void validateQuietZone(BitArray row, int startPattern) throws NotFoundException {

  int quietCount = this.narrowLineWidth * 10;  // expect to find this many pixels of quiet zone

  for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
    if (row.get(i)) {
      break;
    }
    quietCount--;
  }
  if (quietCount != 0) {
    // Unable to find the necessary number of quiet zone pixels.
    throw NotFoundException.getNotFoundInstance();
  }
}
 

static void a(CharSequence charsequence, BitArray bitarray)
{
    int i = charsequence.length();
    for (int j = 0; j < i;)
    {
        int k = -48 + charsequence.charAt(j);
        if (j + 2 < i)
        {
            int l = -48 + charsequence.charAt(j + 1);
            bitarray.appendBits(-48 + charsequence.charAt(j + 2) + (k * 100 + l * 10), 10);
            j += 3;
        } else
        if (j + 1 < i)
        {
            bitarray.appendBits(-48 + charsequence.charAt(j + 1) + k * 10, 7);
            j += 2;
        } else
        {
            bitarray.appendBits(k, 4);
            j++;
        }
    }

}
 

/**
 * Records the size of all runs of white and black pixels, starting with
 * white. This is just like recordPattern, except it records all the
 * counters, and uses our builtin "counters" member for storage.
 * 
 * @param row
 *            row to count from
 */
private void setCounters(BitArray row) throws NotFoundException {
	counterLength = 0;
	// Start from the first white bit.
	int i = row.getNextUnset(0);
	int end = row.getSize();
	if (i >= end) {
		throw NotFoundException.getNotFoundInstance();
	}
	boolean isWhite = true;
	int count = 0;
	while (i < end) {
		if (row.get(i) ^ isWhite) { // that is, exactly one is true
			count++;
		} else {
			counterAppend(count);
			count = 1;
			isWhite = !isWhite;
		}
		i++;
	}
	counterAppend(count);
}
 

static void maybeEmbedVersionInfo(Version version, ByteMatrix matrix) throws WriterException {
  if (version.getVersionNumber() < 7) {  // Version info is necessary if version >= 7.
    return;  // Don't need version info.
  }
  BitArray versionInfoBits = new BitArray();
  makeVersionInfoBits(version, versionInfoBits);

  int bitIndex = 6 * 3 - 1;  // It will decrease from 17 to 0.
  for (int i = 0; i < 6; ++i) {
    for (int j = 0; j < 3; ++j) {
      // Place bits in LSB (least significant bit) to MSB order.
      boolean bit = versionInfoBits.get(bitIndex);
      bitIndex--;
      // Left bottom corner.
      matrix.set(i, matrix.getHeight() - 11 + j, bit);
      // Right bottom corner.
      matrix.set(matrix.getHeight() - 11 + j, i, bit);
    }
  }
}
 

static void maybeEmbedVersionInfo(Version version, ByteMatrix matrix) throws WriterException {
  if (version.getVersionNumber() < 7) {  // Version info is necessary if version >= 7.
    return;  // Don't need version info.
  }
  BitArray versionInfoBits = new BitArray();
  makeVersionInfoBits(version, versionInfoBits);

  int bitIndex = 6 * 3 - 1;  // It will decrease from 17 to 0.
  for (int i = 0; i < 6; ++i) {
    for (int j = 0; j < 3; ++j) {
      // Place bits in LSB (least significant bit) to MSB order.
      boolean bit = versionInfoBits.get(bitIndex);
      bitIndex--;
      // Left bottom corner.
      matrix.set(i, matrix.getHeight() - 11 + j, bit);
      // Right bottom corner.
      matrix.set(matrix.getHeight() - 11 + j, i, bit);
    }
  }
}
 

/**
 * @param row row of black/white values to search
 * @param rowOffset position to start search
 * @param whiteFirst if true, indicates that the pattern specifies white/black/white/...
 * pixel counts, otherwise, it is interpreted as black/white/black/...
 * @param pattern pattern of counts of number of black and white pixels that are being
 * searched for as a pattern
 * @param counters array of counters, as long as pattern, to re-use
 * @return start/end horizontal offset of guard pattern, as an array of two ints
 * @throws NotFoundException if pattern is not found
 */
private static int[] findGuardPattern(BitArray row,
                                      int rowOffset,
                                      boolean whiteFirst,
                                      int[] pattern,
                                      int[] counters) throws NotFoundException {
  int patternLength = pattern.length;
  int width = row.getSize();
  boolean isWhite = whiteFirst;
  rowOffset = whiteFirst ? row.getNextUnset(rowOffset) : row.getNextSet(rowOffset);
  int counterPosition = 0;
  int patternStart = rowOffset;
  for (int x = rowOffset; x < width; x++) {
    if (row.get(x) ^ isWhite) {
      counters[counterPosition]++;
    } else {
      if (counterPosition == patternLength - 1) {
        if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
          return new int[]{patternStart, x};
        }
        patternStart += counters[0] + counters[1];
        System.arraycopy(counters, 2, counters, 0, patternLength - 2);
        counters[patternLength - 2] = 0;
        counters[patternLength - 1] = 0;
        counterPosition--;
      } else {
        counterPosition++;
      }
      counters[counterPosition] = 1;
      isWhite = !isWhite;
    }
  }
  throw NotFoundException.getNotFoundInstance();
}
 

/**
 * Identify where the end of the middle / payload section ends.
 *
 * @param row row of black/white values to search
 * @return Array, containing index of start of 'end block' and end of 'end
 *         block'
 * @throws NotFoundException
 */
int[] decodeEnd(BitArray row) throws NotFoundException {

  // For convenience, reverse the row and then
  // search from 'the start' for the end block
  row.reverse();
  try {
    int endStart = skipWhiteSpace(row);
    int[] endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);

    // The start & end patterns must be pre/post fixed by a quiet zone. This
    // zone must be at least 10 times the width of a narrow line.
    // ref: http://www.barcode-1.net/i25code.html
    validateQuietZone(row, endPattern[0]);

    // Now recalculate the indices of where the 'endblock' starts & stops to
    // accommodate
    // the reversed nature of the search
    int temp = endPattern[0];
    endPattern[0] = row.getSize() - endPattern[1];
    endPattern[1] = row.getSize() - temp;

    return endPattern;
  } finally {
    // Put the row back the right way.
    row.reverse();
  }
}
 

static void append8BitBytes(String content, BitArray bits, String encoding) throws WriterException {
	byte[] bytes;
	try {
		bytes = content.getBytes(encoding);
	} catch (UnsupportedEncodingException uee) {
		throw new WriterException(uee);
	}
	for (byte b : bytes) {
		bits.appendBits(b, 8);
	}
}
 

@Override
public Result decodeRow(int rowNumber,
                        BitArray row,
                        Map<DecodeHintType,?> hints) throws NotFoundException {
  this.reset();
  decodeRow2pairs(rowNumber, row);
  return constructResult(this.pairs);
}
 

private int[] findAsteriskPattern(BitArray row) throws NotFoundException {
  int width = row.getSize();
  int rowOffset = row.getNextSet(0);

  Arrays.fill(counters, 0);
  int[] theCounters = counters;
  int patternStart = rowOffset;
  boolean isWhite = false;
  int patternLength = theCounters.length;

  int counterPosition = 0;
  for (int i = rowOffset; i < width; i++) {
    if (row.get(i) ^ isWhite) {
      theCounters[counterPosition]++;
    } else {
      if (counterPosition == patternLength - 1) {
        if (toPattern(theCounters) == ASTERISK_ENCODING) {
          return new int[]{patternStart, i};
        }
        patternStart += theCounters[0] + theCounters[1];
        System.arraycopy(theCounters, 2, theCounters, 0, patternLength - 2);
        theCounters[patternLength - 2] = 0;
        theCounters[patternLength - 1] = 0;
        counterPosition--;
      } else {
        counterPosition++;
      }
      theCounters[counterPosition] = 1;
      isWhite = !isWhite;
    }
  }
  throw NotFoundException.getNotFoundInstance();
}
 

private static int[] bitsToWords(BitArray stuffedBits, int wordSize, int totalWords) {
  int[] message = new int[totalWords];
  int i;
  int n;
  for (i = 0, n = stuffedBits.getSize() / wordSize; i < n; i++) {
    int value = 0;
    for (int j = 0; j < wordSize; j++) {
      value |= stuffedBits.get(i * wordSize + j) ? (1 << wordSize - j - 1) : 0;
    }
    message[i] = value;
  }
  return message;
}
 

static void append8BitBytes(String content, BitArray bits, String encoding)
    throws WriterException {
  byte[] bytes;
  try {
    bytes = content.getBytes(encoding);
  } catch (UnsupportedEncodingException uee) {
    throw new WriterException(uee);
  }
  for (byte b : bytes) {
    bits.appendBits(b, 8);
  }
}
 

static void append8BitBytes(String content, BitArray bits, String encoding)
    throws WriterException {
  byte[] bytes;
  try {
    bytes = content.getBytes(encoding);
  } catch (UnsupportedEncodingException uee) {
    throw new WriterException(uee);
  }
  for (byte b : bytes) {
    bits.appendBits(b, 8);
  }
}
 

/**
 * Terminate bits as described in 8.4.8 and 8.4.9 of JISX0510:2004 (p.24).
 */
static void terminateBits(int numDataBytes, BitArray bits) throws WriterException {
  int capacity = numDataBytes * 8;
  if (bits.getSize() > capacity) {
    throw new WriterException("data bits cannot fit in the QR Code" + bits.getSize() + " > " +
        capacity);
  }
  for (int i = 0; i < 4 && bits.getSize() < capacity; ++i) {
    bits.appendBit(false);
  }
  // Append termination bits. See 8.4.8 of JISX0510:2004 (p.24) for details.
  // If the last byte isn't 8-bit aligned, we'll add padding bits.
  int numBitsInLastByte = bits.getSize() & 0x07;    
  if (numBitsInLastByte > 0) {
    for (int i = numBitsInLastByte; i < 8; i++) {
      bits.appendBit(false);
    }
  }
  // If we have more space, we'll fill the space with padding patterns defined in 8.4.9 (p.24).
  int numPaddingBytes = numDataBytes - bits.getSizeInBytes();
  for (int i = 0; i < numPaddingBytes; ++i) {
    bits.appendBits((i & 0x01) == 0 ? 0xEC : 0x11, 8);
  }
  if (bits.getSize() != capacity) {
    throw new WriterException("Bits size does not equal capacity");
  }
}
 

/**
 * Records the size of successive runs of white and black pixels in a row,
 * starting at a given point. The values are recorded in the given array,
 * and the number of runs recorded is equal to the size of the array. If the
 * row starts on a white pixel at the given start point, then the first
 * count recorded is the run of white pixels starting from that point;
 * likewise it is the count of a run of black pixels if the row begin on a
 * black pixels at that point.
 * 
 * @param row
 *            row to count from
 * @param start
 *            offset into row to start at
 * @param counters
 *            array into which to record counts
 * @throws NotFoundException
 *             if counters cannot be filled entirely from row before running
 *             out of pixels
 */
protected static void recordPattern(BitArray row, int start, int[] counters) throws NotFoundException {
	int numCounters = counters.length;
	Arrays.fill(counters, 0, numCounters, 0);
	int end = row.getSize();
	if (start >= end) {
		throw NotFoundException.getNotFoundInstance();
	}
	boolean isWhite = !row.get(start);
	int counterPosition = 0;
	int i = start;
	while (i < end) {
		if (row.get(i) ^ isWhite) { // that is, exactly one is true
			counters[counterPosition]++;
		} else {
			counterPosition++;
			if (counterPosition == numCounters) {
				break;
			} else {
				counters[counterPosition] = 1;
				isWhite = !isWhite;
			}
		}
		i++;
	}
	// If we read fully the last section of pixels and filled up our
	// counters -- or filled
	// the last counter but ran off the side of the image, OK. Otherwise, a
	// problem.
	if (!(counterPosition == numCounters || (counterPosition == numCounters - 1 && i == end))) {
		throw NotFoundException.getNotFoundInstance();
	}
}
 

/**
 * Identify where the start of the middle / payload section starts.
 *
 * @param row row of black/white values to search
 * @return Array, containing index of start of 'start block' and end of
 *         'start block'
 */
private int[] decodeStart(BitArray row) throws NotFoundException {
  int endStart = skipWhiteSpace(row);
  int[] startPattern = findGuardPattern(row, endStart, START_PATTERN);

  // Determine the width of a narrow line in pixels. We can do this by
  // getting the width of the start pattern and dividing by 4 because its
  // made up of 4 narrow lines.
  this.narrowLineWidth = (startPattern[1] - startPattern[0]) / 4;

  validateQuietZone(row, startPattern[0]);

  return startPattern;
}
 

private static int a(BitArray bitarray, int i1)
{
    if (bitarray.get(i1))
    {
        return bitarray.getNextSet(bitarray.getNextUnset(i1));
    } else
    {
        return bitarray.getNextUnset(bitarray.getNextSet(i1));
    }
}