Checks whether the cell should be split.  We're just doing the same thing that SEMPRE did
        here.
963400
def _should_split_cell(cls, cell_text: str) -> bool:
        
        if ', ' in cell_text or '\n' in cell_text or '/' in cell_text:
            return True
        return False
1359213
function(){
		this.decodeCell( function(cell,ca){
			if     (ca==="#"){ cell.qans = 1;}
			else if(ca==="+"){ cell.qsub = 1;}
			else if(ca==="-"){ cell.qnum = -2;}
			else if(ca!=="."){ cell.qnum = +ca;}
		});
	}
1258870
def is_equal(self, other):
        
        other = StringCell.coerce(other)
        empties = [None,'']
        if self.value in empties and other.value in empties:
            return True
        return self.value == other.value
340627
function shouldInheritGap (selA, selB) {
  let result

  // get arrays of selector split in 3-deep array
  let splitSelectorArrA = splitSelector(selA)
  let splitSelectorArrB = splitSelector(selB)

  if (splitSelectorArrA[0].length < splitSelectorArrB[0].length) {
    // abort if selectorA has lower descendant specificity then selectorB
    // (e.g '.grid' and '.hello .world .grid')
    return false
  } else if (splitSelectorArrA[0].length > splitSelectorArrB[0].length) {
    // if selectorA has higher descendant specificity then selectorB
    // (e.g '.foo .bar .grid' and '.grid')

    let idx = splitSelectorArrA[0].reduce((res, [item], index) => {
      let firstSelectorPart = splitSelectorArrB[0][0][0]
      if (item === firstSelectorPart) {
        return index
      }
      return false
    }, false)

    if (idx) {
      result = splitSelectorArrB[0].every((arr, index) => {
        return arr.every((part, innerIndex) =>
          // because selectorA has more space elements, we need to slice
          // selectorA array by 'idx' number to compare them
          splitSelectorArrA[0].slice(idx)[index][innerIndex] === part)
      })
    }
  } else {
    // if selectorA has the same descendant specificity as selectorB
    // this condition covers cases such as: '.grid.foo.bar' and '.grid'
    result = splitSelectorArrB.some(byCommaArr => {
      return byCommaArr.every((bySpaceArr, index) => {
        return bySpaceArr.every(
          (part, innerIndex) => splitSelectorArrA[0][index][innerIndex] === part
        )
      })
    })
  }

  return result
}
961640
function(){
		var piece = this.getcell_excell(); /* piece : cell or excell */
		if(piece.isnull){ return;}

		var group = piece.group;
		if(group==='excell' || (group==='cell' && piece!==this.cursor.getc())){
			this.setcursor(piece);
		}
		else if(group==='cell'){
			this.input51_main(piece);
		}
	}
591364
public boolean inSameCell(int elementI, int elementJ) {
        for (int cellIndex = 0; cellIndex < size(); cellIndex++) {
            SortedSet<Integer> cell = getCell(cellIndex);
            if (cell.contains(elementI) && cell.contains(elementJ)) {
                return true;
            }
        }
        return false;
    }
79222
public void acceptCell(C cell) {
        cell.reset();
        if(cell.isReusable()) {
            pool.add(cell);
        } else {
            cell.dispose();
        }
    }
390435
public void doesNotContainCell(Cell<?, ?, ?> cell) {
    checkNotNull(cell);
    checkNoNeedToDisplayBothValues("cellSet()").that(actual().cellSet()).doesNotContain(cell);
  }
335906
public boolean matches(Example cells)
    {
        for (int i = 0; i < cells.remainings(); ++i)
        {
            Example cell = cells.at( i );

            if (i < headers.length)
            {
                ExpectedColumn column = (ExpectedColumn) headers[i];
                String message = column.header();

                if (HeaderForm.parse(message).isExpected()) continue;
                if (StringUtil.isBlank( contentOf( cell ) )) {
                    if (column.getClass() == ExpectedColumn.class) continue;

                    try
                    {
                        column.setCheck(fixture.check(column.header()));
                        final Statistics statistics = column.doCell(cell, false);

                        if (statistics.indicatesFailure())
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                } else { // Check for equality
                    try
                    {
                        Call call = new Call( fixture.check( column.header() ) );
                        Expectation expectation = ShouldBe.literal( contentOf( cell ) );

                        Object result = call.execute();
                        if (!expectation.meets( result ))
                        {
                            return false;
                        }
                    }
                    catch (Exception e)
                    {
                        return false;
                    }
                }


            }
        }

        return true;
    }
392756
private void checkCell(int start, int end) {
        if (start > nplus - 1 || end > nplus || start < 0 || end < 1) {
            throw new IllegalStateException(String.format("Invalid cell: start=%d end=%d", start, end));
        }
    }
582627
def is_cell_empty(self, cell):
    """"""
    if cell is None:
      return True
    elif self._is_cell_empty:
      return self._is_cell_empty(cell)
    else:
      return cell is None
589843
function(){
		this.puzzle.opemgr.newOperation();
		
		this.cell.subclear();
		this.cross.subclear();
		this.border.subclear();
		this.excell.subclear();
	}
196077
function trimCell( cell )
	{
		var bogus = cell.getBogus();
		bogus && bogus.remove();
		cell.trim();
	}
874474
def split_on_condition(seq, condition):
    """"""
    l1, l2 = tee((condition(item), item) for item in seq)
    return (i for p, i in l1 if p), (i for p, i in l2 if not p)
815707
private static void splitMult(double a[], double b[], double ans[]) {
        ans[0] = a[0] * b[0];
        ans[1] = a[0] * b[1] + a[1] * b[0] + a[1] * b[1];

        /* Resplit */
        resplit(ans);
    }
578576
function flushCurrentCell() {
        if (currentCell.children.length > 0) {
            cells.push(currentCell);
            currentCell = N.tag("div");
            cellsWeights.push(1);
            totalWeight++;
        }
    }
605950
function(){
		var cell = this.getcell();
		if(cell.isnull || cell===this.mouseCell){ return;}

		if(this.inputMode==='clear'){
			cell.remove51cell();
			this.inputData = 0;
		}
		else if(this.inputMode==='cell51' && !cell.is51cell()){
			cell.set51cell();
			this.inputData = 51;
		}

		cell.drawaround();

		this.mouseCell = cell;
	}