} else {
            final Object oldValue = dataMap.get(key);
            final Object[] oldValues;
            if (oldValue instanceof Object[]) {
                oldValues = (Object[]) oldValue;
            } else if (oldValue instanceof Collection<?>) {
                oldValues = ((Collection<?>) oldValue).toArray();
            } else {
                oldValues = new Object[] { oldValue };
            }

  public void testReplaceValuesWithEmpty() {
    int size = multimap().size();
    List<V> oldValues = new ArrayList<>(multimap().get(k0()));
    List<V> values = Collections.emptyList();
    assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values)));
    assertGet(k0());
    assertEquals(size - oldValues.size(), multimap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})

  public void testReplaceValuesWithEmpty() {
    int size = multimap().size();
    List<V> oldValues = new ArrayList<>(multimap().get(k0()));
    List<V> values = Collections.emptyList();
    assertEquals(oldValues, new ArrayList<V>(multimap().replaceValues(k0(), values)));
    assertGet(k0());
    assertEquals(size - oldValues.size(), multimap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})

t+"box-flex":super.prefixed(e,t)}normalize(){return"flex"}set(e,t){let r=Pg(t)[0];if(r===2009)return e.value=Tg.space(e.value)[0],e.value=Yt.oldValues[e.value]||e.value,super.set(e,t);if(r===2012){let n=Tg.space(e.value);n.length===3&&n[2]==="0"&&(e.value=n.slice(0,2).concat("0px").join(" "))}return super.set(e,t)}};Yt.names=["flex","box-flex"];Yt.oldValues={auto:"1",none:"0"};Dg.exports=Yt});var Mg=v((P4,Rg)=>{l();var qg=pe(),_A=M(),al=class extends _A{prefixed(e,t){let r;return[r,t]=qg(t),r===...

                @Override
                public DaemonRegistryContent update(DaemonRegistryContent oldValue) {
                    if (oldValue == null) {
                        return oldValue;
                    }
                    oldValue.removeInfo(((InetEndpoint)address).getPort());
                    return oldValue;
                }
            });
        } finally {
            lock.unlock();
        }

      }

      while (true) {
        int oldValue = existingCounter.get();
        if (oldValue != 0) {
          try {
            int newValue = IntMath.checkedAdd(oldValue, occurrences);
            if (existingCounter.compareAndSet(oldValue, newValue)) {
              // newValue can't == 0, so no need to check & remove
              return oldValue;
            }
          } catch (ArithmeticException overflow) {

        Object oldValue;
        synchronized (delegate) {
            oldValue = delegate.putIfAbsent(key, value);
        }
        reportAccess(key, oldValue);
        if (oldValue == null) {
            // Properties disallow null values, so it is safe to assume that the map was changed.
            reportChange(key, value);
        }
        return oldValue;

    }

    @Override

      while (true) {
        long oldValue = atomic.get();
        if (oldValue == 0L) {
          // don't compareAndSet a zero
          if (map.replace(key, atomic, new AtomicLong(delta))) {
            return 0L;
          }
          // atomic replaced
          continue outer;
        }

        long newValue = oldValue + delta;
        if (atomic.compareAndSet(oldValue, newValue)) {
          return oldValue;

                      case 6:
                        long oldValue = map.put(key, delta);
                        threadSum += delta - oldValue;
                        break;
                      case 7:
                        oldValue = map.get(key);
                        if (map.replace(key, oldValue, delta)) {
                          threadSum += delta - oldValue;
                        }
                        break;

                      case 6:
                        long oldValue = map.put(key, delta);
                        threadSum += delta - oldValue;
                        break;
                      case 7:
                        oldValue = map.get(key);
                        if (map.replace(key, oldValue, delta)) {
                          threadSum += delta - oldValue;
                        }
                        break;