2. Boost Unordered Translation (zh_Hans)
3. English
4. Zen

:1226 :1226
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
338 :1434
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Inserts an element constructed from `k` and `args` into the table if there is no existing element with key `k` contained within it, and then invokes `f1` with a non-const reference to the newly created element. Otherwise, invokes `f2` with a reference to the equivalent element; such reference is const iff a `*_cvisit` overload is used. 337/10000 · 337
:1451 :1451
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
338 :1328
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — hash_function 13/10000 · 13
338 :1234
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — bucket_size 11/10000 · 11
338 :1328
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; The number of elements erased (0 or 1). Throws:;; Only throws an exception if it is thrown by `hasher`, `key_equal` or `f`. Notes:;; The `template<class K, class F>` overload only participates in overload resolution if `std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` is `false`. + + The `template<class K, class F>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type. 679/10000 · 679
338 :1317
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — count 5/10000 · 5
338 :1199
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ template<class Key, class T, class Hash, class Pred, class Alloc> bool operator==(const unordered_flat_set<Key, T, Hash, Pred, Alloc>& x, const unordered_flat_set<Key, T, Hash, Pred, Alloc>& y); ``` 205/10000 · 205
338 :1235
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Requires:;; `n` shall be in the range `[0, bucket_count())`. Returns:;; A local iterator pointing the 'one past the end' element in the bucket with index `n`. 158/10000 · 158
338 :1313
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ float max_load_factor() const noexcept; ``` 50/10000 · 50
339 :1348
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — The behavior of this function is undefined if `this\->get_allocator() != source.get_allocator()`. 97/10000 · 97
339 :1272
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ size_type bucket_size(size_type n) const; ``` 52/10000 · 52
339 :1228
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — rehash 6/10000 · 6
:1439 :1439
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Returns:;; `true` if an insert took place. + Concurrency:;; Blocking on rehashing of `*this`. Notes:;; No `value_type` is constructed if there is an element with an equivalent key; otherwise, the construction is of the form: + + -- ```c++ 238/10000 · 238
339 :1453
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Parallel erase_if 17/10000 · 17
339 :1329
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ``` hasher hash_function() const; ``` 37/10000 · 37
339 :1235
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ size_type bucket_size(size_type n) const; ``` 52/10000 · 52
:1334 :1334
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — --- 3/10000 · 3
339 :1318
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — ```c++ size_type count(const key_type& k) const; template<class K> size_type count(const K& k) const; ``` 117/10000 · 117
339 :1205
	English ↹ ↵ NBS … “ ” ‘ ’ ﹙-﹚ ‐ – — Return `true` if `x.size() == y.size()` and for every element in `x`, there is an element in `y` with the same key, with an equal value (using `operator==` to compare the value types). 184/10000 · 184