*       stateless, and therefore thread-safe.
 *   <li><b>collision-averse:</b> while it can't be helped that a hash function will sometimes
 *       produce the same hash code for distinct inputs (a "collision"), every hash function strives
 *       to <i>some</i> degree to make this unlikely. (Without this condition, a function that
 *       always returns zero could be called a hash function. It is not.)
 * </ul>

 *       stateless, and therefore thread-safe.
 *   <li><b>collision-averse:</b> while it can't be helped that a hash function will sometimes
 *       produce the same hash code for distinct inputs (a "collision"), every hash function strives
 *       to <i>some</i> degree to make this unlikely. (Without this condition, a function that
 *       always returns zero could be called a hash function. It is not.)
 * </ul>

        return node.elemCount;
      }

      @Override
      long treeAggregate(@CheckForNull AvlNode<?> root) {
        return (root == null) ? 0 : root.totalCount;
      }
    },
    DISTINCT {
      @Override
      int nodeAggregate(AvlNode<?> node) {
        return 1;
      }

      @Override
      long treeAggregate(@CheckForNull AvlNode<?> root) {

    assertThat(at.doubleValue()).isEqualTo(0.0d);
    for (double x : VALUES) {
      at.set(x);
      assertBitEquals(x, at.doubleValue());
    }
  }

  /** compareAndSet treats +0.0 and -0.0 as distinct values */
  public void testDistinctZeros() {
    AtomicDouble at = new AtomicDouble(+0.0);
    assertFalse(at.compareAndSet(-0.0, 7.0));
    assertFalse(at.weakCompareAndSet(-0.0, 7.0));

				continue
			}
		}
		return true
	}
	return false
}

// FilterTargetArns returns a slice of distinct target arns in the config
func (c Config) FilterTargetArns(obj ObjectOpts) []string {
	var arns []string

	tgtsMap := make(map[string]struct{})
	rules := c.FilterActionableRules(obj)
	for _, rule := range rules {

        final List<String> pagingQueryList = new ArrayList<>();
        if (form.ex_q != null) {
            stream(form.ex_q).of(stream -> stream.filter(StringUtil::isNotBlank).distinct()
                    .forEach(q -> pagingQueryList.add("ex_q=" + LaFunctions.u(q))));
        }
        if (StringUtil.isNotBlank(form.sort)) {
            pagingQueryList.add("sort=" + LaFunctions.u(form.sort));

            // FIXME There should be no duplicates, yet there are some
            return upgradedProperties.stream()
                .distinct()
                .collect(ImmutableList.toImmutableList());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    /**

                .filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]));
    }

    default String getSearchDefaultDisplayPermission() {
        return split(getRoleSearchDefaultDisplayPermissions(), ",")
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().collect(Collectors.joining("\n")));
    }

    String getQueryGeoFields();

  abstract Iterator<Entry<K, V>> entryIterator();

  Spliterator<Entry<K, V>> entrySpliterator() {
    return Spliterators.spliterator(
        entryIterator(), size(), (this instanceof SetMultimap) ? Spliterator.DISTINCT : 0);
  }

  @LazyInit @CheckForNull private transient Set<K> keySet;

  @Override
  public Set<K> keySet() {
    Set<K> result = keySet;
    return (result == null) ? keySet = createKeySet() : result;

	// works, but only when running one binary at a time.
	// Use a file lock to make sure only one wrapper is running at a time.
	//
	// The lock file is never deleted, to avoid concurrent locks on distinct
	// files with the same path.
	lockName := filepath.Join(os.TempDir(), "go_ios_exec-"+deviceID+".lock")
	lock, err = os.OpenFile(lockName, os.O_CREATE|os.O_RDONLY, 0666)
	if err != nil {
		return 1, err
	}