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 (;;) {
          CounterCell[] cs; 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
                    CounterCell r = new CounterCell(x); // Optimistic create
                      if (cellsBusy == 0 &&
                          Unsafe.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                          boolean created = false;
                          try {               // Recheck under lock
                            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 (Unsafe.compareAndSwapLong(c, CELLVALUE, 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 &&
                       Unsafe.compareAndSwapInt(this, CELLSBUSY, 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 &&
                   Unsafe.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
              boolean init = false;
              try {                           // Initialize table
                  if (counterCells == cs) {
                    CounterCell[] rs = new CounterCell[2];
                      rs[h & 1] = new CounterCell(x);
                      counterCells = rs;
                      init = true;
                  }
              } finally {
                  cellsBusy = 0;
              }
            if (init) {
              break;
            }
          }
          else if (Unsafe.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x)) {
            break;                          // Fall back on using base
          }
      }
  }
private final void fullAddCount(long x, boolean wasUncontended)