private final void fullAddCount(long x, boolean wasUncontended) {
      int h;
      if ((h = ThreadLocalRandom.getProbe()) == 0) {
          ThreadLocalRandom.localInit();      // force initialization
          h = ThreadLocalRandom.getProbe();
          wasUncontended = true;
      }
      boolean collide = false;                // True if last slot nonempty
      for (;;) {
          ConcurrentHashMap.CounterCell[] cs; ConcurrentHashMap.CounterCell c; int n; long v;
          if ((cs = counterCells) != null && (n = cs.length) > 0) {
              if ((c = cs[(n - 1) & h]) == null) {
                  if (cellsBusy == 0) {            // Try to attach new Cell
                    ConcurrentHashMap.CounterCell r = new ConcurrentHashMap.CounterCell(x); // Optimistic create
                      if (cellsBusy == 0 &&
                          CELLSBUSY.compareAndSet(this, 0, 1)) {
                          boolean created = false;
                          try {               // Recheck under lock
                            ConcurrentHashMap.CounterCell[] rs; int m, j;
                              if ((rs = counterCells) != null &&
                                  (m = rs.length) > 0 &&
                                  rs[j = (m - 1) & h] == null) {
                                  rs[j] = r;
                                  created = true;
                              }
                          } finally {
                              cellsBusy = 0;
                          }
                          if (created)
                              break;
                          continue;           // Slot is now non-empty
                      }
                  }
                  collide = false;
              }
              else if (!wasUncontended)       // CAS already known to fail
                  wasUncontended = true;      // Continue after rehash
              else if (ConcurrentHashMap.CELLVALUE.compareAndSet(c, v = c.value, v + x))
                  break;
              else if (counterCells != cs || n >= NCPU)
                  collide = false;            // At max size or stale
              else if (!collide)
                  collide = true;
              else if (cellsBusy == 0 &&
                       CELLSBUSY.compareAndSet(this, 0, 1)) {
                  try {
                      if (counterCells == cs) // Expand table unless stale
                          counterCells = Arrays.copyOf(cs, n << 1);
                  } finally {
                      cellsBusy = 0;
                  }
                  collide = false;
                  continue;                   // Retry with expanded table
              }
              h = ThreadLocalRandom.advanceProbe(h);
          }
          else if (cellsBusy == 0 && counterCells == cs &&
                   CELLSBUSY.compareAndSet(this, 0, 1)) {
              boolean init = false;
              try {                           // Initialize table
                  if (counterCells == cs) {
                    ConcurrentHashMap.CounterCell[] rs = new ConcurrentHashMap.CounterCell[2];
                      rs[h & 1] = new ConcurrentHashMap.CounterCell(x);
                      counterCells = rs;
                      init = true;
                  }
              } finally {
                  cellsBusy = 0;
              }
              if (init)
                  break;
          }
          else if (BASECOUNT.compareAndSet(this, v = baseCount, v + x))
              break;                          // Fall back on using base
      }
  }
private final void fullAddCount(long x, boolean wasUncontended)