encodings[ 0x4] = encoding // End of Transmission
      encodings[ 0x5] = encoding // Enquiry
      encodings[ 0x6] = encoding // Acknowledgment
      encodings[ 0x7] = encoding // Bell
      encodings['\b'.code] = encoding // Backspace
      encodings[ 0xb] = encoding // Vertical Tab
      encodings[ 0xe] = encoding // Shift Out
      encodings[ 0xf] = encoding // Shift In

   * Acknowledge: A communication control character transmitted by a receiver as an affirmative
   * response to a sender.
   *
   * @since 8.0
   */
  public static final byte ACK = 6;

  /**
   * Bell ('\a'): A character for use when there is a need to call for human attention. It may
   * control alarm or attention devices.
   *
   * @since 8.0
   */
  public static final byte BEL = 7;

  /**

    boolean collide = false; // True if last slot nonempty
    for (; ; ) {
      Cell[] as;
      Cell a;
      int n;
      long v;
      if ((as = cells) != null && (n = as.length) > 0) {
        if ((a = as[(n - 1) & h]) == null) {
          if (busy == 0) { // Try to attach new Cell
            Cell r = new Cell(x); // Optimistically create
            if (busy == 0 && casBusy()) {

        checkNotNull(cell.getValue(), "value");
        @SuppressWarnings("unchecked") // all supported methods are covariant
        Cell<R, C, V> immutableCell = (Cell<R, C, V>) cell;
        cells.add(immutableCell);
      } else {
        put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
      }
      return this;
    }

    /**

        checkNotNull(cell.getValue(), "value");
        @SuppressWarnings("unchecked") // all supported methods are covariant
        Cell<R, C, V> immutableCell = (Cell<R, C, V>) cell;
        cells.add(immutableCell);
      } else {
        put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
      }
      return this;
    }

    /**

        },
        "italian_elision": {
          "type":         "elision",
          "articles": [
                "c", "l", "all", "dall", "dell",
                "nell", "sull", "coll", "pell",
                "gl", "agl", "dagl", "degl", "negl",
                "sugl", "un", "m", "t", "s", "v", "d"
          ]
        },
        "italian_stop": {
          "type":       "stop",

      return Maps.transformValues(fromTable.column(columnKey), function);
    }

    Cell<R, C, V2> applyToValue(Cell<R, C, V1> cell) {
      return immutableCell(cell.getRowKey(), cell.getColumnKey(), function.apply(cell.getValue()));
    }

    @Override
    Iterator<Cell<R, C, V2>> cellIterator() {
      return Iterators.transform(fromTable.cellSet().iterator(), this::applyToValue);
    }

   * row, and so on.
   *
   * <p>Each cell is an immutable snapshot of a row key / column key / value mapping, taken at the
   * time the cell is returned by a method call to the set or its iterator.
   */
  @Override
  public Set<Cell<R, C, V>> cellSet() {
    return super.cellSet();
  }

  @Override
  Iterator<Cell<R, C, V>> cellIterator() {
    return new CellIterator();
  }

              return (Table<String, String, Integer>) table;
            });
    Cell<String, String, @Nullable Integer> cell = immutableCell("one", "uno", null);
    assertThrows(
        NullPointerException.class,
        () -> Stream.of((Cell<String, String, Integer>) cell).collect(collector));
  }

  public void testToTableConflict() {
    Collector<Cell<String, String, Integer>, ?, Table<String, String, Integer>> collector =

    }

    @Override
    public Set<Cell<String, Integer, Character>> create(Object... elements) {
      Table<String, Integer, Character> table = createTable();
      for (Object element : elements) {
        @SuppressWarnings("unchecked")
        Cell<String, Integer, Character> cell = (Cell<String, Integer, Character>) element;
        table.put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
      }