currentClosuresEntries.computeInt(thisClosure, (key, oldValue) -> {
            if (oldValue == null) {
                throw new IllegalStateException("leaveClosure called with an untracked instance");
            } else {
                if (oldValue == 1) {
                    return null;
                } else {
                    return oldValue - 1;
                }
            }
        });
    }

	}

	defer func() {
		r.comparisonResult = &res
	}()

	if r.Value == nil && r.OldValue == nil {
		return true
	} else if r.Value == nil || r.OldValue == nil {
		return false
	}

	oldAsArray, oldIsArray := r.OldValue.([]interface{})
	newAsArray, newIsArray := r.Value.([]interface{})

	oldAsMap, oldIsMap := r.OldValue.(map[string]interface{})
	newAsMap, newIsMap := r.Value.(map[string]interface{})

    Long result =
        map.compute(
            key,
            (k, oldValue) -> {
              if (oldValue == null || oldValue == 0) {
                noValue.set(true);
                return newValue;
              } else {
                return oldValue;
              }
            });
    return noValue.get() ? 0L : requireNonNull(result).longValue();
  }

    // The cast is safe because the callers of this method first check that the key is present.
    V oldValue = uncheckedCastNullableTToT(delegate.remove(key));
    removeFromInverseMap(oldValue);
    return oldValue;
  }

  private void removeFromInverseMap(@ParametricNullness V oldValue) {
    inverse.delegate.remove(oldValue);
  }

  // Bulk Operations

  @Override
  public void putAll(Map<? extends K, ? extends V> map) {

    public V put(K key, V value) {
        V oldValue = get(key);
        delegate.put(key, value);
        return oldValue;
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        delegate.putAll(m);
    }

    @Override
    @Nullable
    public V remove(Object key) {
        Map<K, V> map = new LinkedHashMap<>(delegate.get());
        V oldValue = map.remove(key);
        delegate.set(map);

      Entry<K, V> e = RegularImmutableMap.makeImmutable(requireNonNull(entryArray[i]));
      entryArray[i] = e;
      V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
      if (oldValue != null) {
        throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
      }
      K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
      if (oldKey != null) {

        }

        fun systemPropertyLoaded(key: Any, value: Any?, oldValue: Any?) {
            val loadedOldValue = when (val loadedSystemProperty = mutatedSystemProperties[key]) {
                is SystemPropertyLoad -> loadedSystemProperty.oldValue
                else -> oldValue
            }

            mutatedSystemProperties[key] = SystemPropertyLoad(key, value, loadedOldValue)

   *     the thread's interrupt status is set
   * @since 11.0
   */
  @GwtIncompatible // Futures
  public ListenableFuture<V> reload(K key, V oldValue) throws Exception {
    checkNotNull(key);
    checkNotNull(oldValue);
    return Futures.immediateFuture(load(key));
  }

  /**
   * Computes or retrieves the values corresponding to {@code keys}. This method is called by {@link

        return store.maybeUpdate(new ObjectHolder.UpdateAction<UniqueId>() {
            @Override
            public UniqueId update(UniqueId oldValue) {
                if (oldValue == null) {
                    return generator.create();
                } else {
                    return oldValue;
                }
            }
        });
    }

    private ObjectHolder<UniqueId> store(ScopeParams params) {

      K key = entryArray[i].getKey();
      V value = entryArray[i].getValue();
      V oldValue = delegateMap.put(key, value);
      if (oldValue != null) {
        if (throwIfDuplicateKeys) {
          throw conflictException("key", entryArray[i], entryArray[i].getKey() + "=" + oldValue);
        }
        if (duplicates == null) {
          duplicates = new HashMap<>();
        }