// Note: Not all random access lists support set(). Additionally, it's possible
    // for a list to reject setting an element, such as when the list does not permit
    // duplicate elements. For both of those cases,  we need to fall back to a slower
    // implementation.
    int from = 0;
    int to = 0;

    for (; from < list.size(); from++) {
      T element = list.get(from);
      if (!predicate.apply(element)) {

		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "cq":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Curr")
				return
			}
			for zb0002 > 0 {
				zb0002--

  Burstable QoS pods. For Best-Effort/Guaranteed QoS pods, swap would be disabled.
  
  Containers with memory requests equal to their memory limits also won't have
  swap access, and it is a way to opt-out of swap for a single container.
  
  The formula for the swap limit for Burstable QoS pods is:
  `(<memory-request>/<node-memory-capacity>)*<node-swap-capacity>`.
  

        for (String fieldName : fieldNames) {
            String encoded = BaseEncoding.base64().encode(fieldName.getBytes(StandardCharsets.UTF_8));
            String decoded = new String(BaseEncoding.base64().decode(encoded), StandardCharsets.UTF_8);
            assertEquals("Failed for field: " + fieldName, fieldName, decoded);
        }
    }

          if (rule.startsWith(EXCEPTION_RULE_MARKER)) {
            rule = rule.substring(1)
            // We use '\n' for end of value.
            totalExceptionRuleBytes += rule.size + 1
            sortedExceptionRules.add(rule)
          } else {
            totalRuleBytes += rule.size + 1 // We use '\n' for end of value.
            sortedRules.add(rule)
          }
        }
      }

import com.google.common.annotations.VisibleForTesting;
import java.math.BigInteger;

/**
 * Utilities for {@code double} primitives.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
final class DoubleUtils {
  private DoubleUtils() {}

  static double nextDown(double d) {
    return -Math.nextUp(-d);
  }

  // The mask for the significand, according to the {@link
  // Double#doubleToRawLongBits(double)} spec.

 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

                                    <la:errors property="_global"/>
                                </div>
                                <div class="form-group row">
                                    <label for="regex" class="col-sm-3 text-sm-right col-form-label"><la:message
                                            key="labels.regex"/></label>
                                    <div class="col-sm-9">

    extends AbstractListMultimapTester<K, V> {
  public void testAsMapValuesImplementList() {
    for (Collection<V> valueCollection : multimap().asMap().values()) {
      assertTrue(valueCollection instanceof List);
    }
  }

  public void testAsMapGetImplementsList() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof List);
    }
  }