private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for(int i = 1; i < this.pairs.size(); ++i){
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

private boolean a()
{
    b b1 = (b)o.get(0);
    DataCharacter datacharacter = b1.b();
    int i1 = b1.c().getChecksumPortion();
    int j1 = 2;
    int k1 = i1;
    for (int l1 = 1; l1 < o.size(); l1++)
    {
        b b2 = (b)o.get(l1);
        k1 += b2.b().getChecksumPortion();
        j1++;
        DataCharacter datacharacter1 = b2.c();
        if (datacharacter1 != null)
        {
            k1 += datacharacter1.getChecksumPortion();
            j1++;
        }
    }

    return k1 % 211 + 211 * (j1 - 4) == datacharacter.getValue();
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for (int i = 1; i < this.pairs.size(); ++i) {
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do {
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null) {
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  } while (keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);

  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size() - 1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }

  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch (NotFoundException ignored) {
    rightChar = null;
  }
  return new ExpandedPair(leftChar, rightChar, pattern, true);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for (int i = 1; i < this.pairs.size(); ++i) {
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do {
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null) {
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  } while (keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);

  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size() - 1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }

  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch (NotFoundException ignored) {
    rightChar = null;
  }
  return new ExpandedPair(leftChar, rightChar, pattern, true);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for (int i = 1; i < this.pairs.size(); ++i) {
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do {
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null) {
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  } while (keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);

  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size() - 1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }

  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch (NotFoundException ignored) {
    rightChar = null;
  }
  return new ExpandedPair(leftChar, rightChar, pattern, true);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for(int i = 1; i < this.pairs.size(); ++i){
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do{
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null){
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  }while(keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);
  
  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size()-1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }
  
  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch(NotFoundException ignored) {
    rightChar = null;
  }
  boolean mayBeLast = true;
  return new ExpandedPair(leftChar, rightChar, pattern, mayBeLast);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for(int i = 1; i < this.pairs.size(); ++i){
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do{
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null){
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  }while(keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);
  
  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size()-1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }
  
  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch(NotFoundException ignored) {
    rightChar = null;
  }
  boolean mayBeLast = true;
  return new ExpandedPair(leftChar, rightChar, pattern, mayBeLast);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for(int i = 1; i < this.pairs.size(); ++i){
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do{
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null){
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  }while(keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);
  
  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size()-1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }
  
  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch(NotFoundException ignored) {
    rightChar = null;
  }
  boolean mayBeLast = true;
  return new ExpandedPair(leftChar, rightChar, pattern, mayBeLast);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

private boolean checkChecksum() {
  ExpandedPair firstPair = this.pairs.get(0);
  DataCharacter checkCharacter = firstPair.getLeftChar();
  DataCharacter firstCharacter = firstPair.getRightChar();

  if (firstCharacter == null) {
    return false;
  }

  int checksum = firstCharacter.getChecksumPortion();
  int s = 2;

  for (int i = 1; i < this.pairs.size(); ++i) {
    ExpandedPair currentPair = this.pairs.get(i);
    checksum += currentPair.getLeftChar().getChecksumPortion();
    s++;
    DataCharacter currentRightChar = currentPair.getRightChar();
    if (currentRightChar != null) {
      checksum += currentRightChar.getChecksumPortion();
      s++;
    }
  }

  checksum %= 211;

  int checkCharacterValue = 211 * (s - 4) + checksum;

  return checkCharacterValue == checkCharacter.getValue();
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;
  if (startFromEven) {
    isOddPattern = !isOddPattern;
  }

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do {
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null) {
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  } while (keepFinding);

  // When stacked symbol is split over multiple rows, there's no way to guess if this pair can be last or not.
  // boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);
  
  if (!previousPairs.isEmpty() && previousPairs.get(previousPairs.size() - 1).mustBeLast()) {
    throw NotFoundException.getNotFoundInstance();
  }
  
  DataCharacter rightChar;
  try {
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  } catch (NotFoundException ignored) {
    rightChar = null;
  }
  return new ExpandedPair(leftChar, rightChar, pattern, true);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar = leftChar;
  this.rightChar = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast = mayBeLast;
}
 

ExpandedPair retrieveNextPair(BitArray row, List<ExpandedPair> previousPairs, int rowNumber)
    throws NotFoundException {
  boolean isOddPattern  = previousPairs.size() % 2 == 0;

  FinderPattern pattern;

  boolean keepFinding = true;
  int forcedOffset = -1;
  do{
    this.findNextPair(row, previousPairs, forcedOffset);
    pattern = parseFoundFinderPattern(row, rowNumber, isOddPattern);
    if (pattern == null){
      forcedOffset = getNextSecondBar(row, this.startEnd[0]);
    } else {
      keepFinding = false;
    }
  }while(keepFinding);

  boolean mayBeLast = checkPairSequence(previousPairs, pattern);

  DataCharacter leftChar  = this.decodeDataCharacter(row, pattern, isOddPattern, true);
  DataCharacter rightChar;
  try{
    rightChar = this.decodeDataCharacter(row, pattern, isOddPattern, false);
  }catch(NotFoundException nfe){
    if(mayBeLast) {
      rightChar = null;
    } else {
      throw nfe;
    }
  }
  return new ExpandedPair(leftChar, rightChar, pattern, mayBeLast);
}
 

ExpandedPair(DataCharacter leftChar,
             DataCharacter rightChar,
             FinderPattern finderPattern,
             boolean mayBeLast) {
  this.leftChar      = leftChar;
  this.rightChar     = rightChar;
  this.finderPattern = finderPattern;
  this.mayBeLast     = mayBeLast;
}
 

b(DataCharacter datacharacter, DataCharacter datacharacter1, FinderPattern finderpattern, boolean flag)
{
    b = datacharacter;
    c = datacharacter1;
    d = finderpattern;
    a = flag;
}
 

DataCharacter getLeftChar() {
  return this.leftChar;
}
 

DataCharacter getRightChar() {
  return this.rightChar;
}
 

DataCharacter getLeftChar() {
  return this.leftChar;
}
 

DataCharacter getRightChar() {
  return this.rightChar;
}