ImmutableBiMap.Builder<String, String> builder = ImmutableBiMap.builder();
      for (Entry<String, String> entry : entries) {
        checkNotNull(entry);
        builder.put(entry.getKey(), entry.getValue());
      }
      return builder.build();
    }
  }

  public static class ImmutableBiMapCopyOfGenerator extends TestStringBiMapGenerator {
    @Override

      for (Object element : elements) {
        @SuppressWarnings("unchecked")
        Entry<String, Integer> entry = (Entry<String, Integer>) element;
        multimap.put(entry.getKey(), entry.getValue());
      }
      return multimap.entries();
    }

    abstract Multimap<String, Integer> createMultimap();

    @Override
    @SuppressWarnings("unchecked")

    for (Entry<K, V> entry : getSampleElements()) {
      expected.add(entry.getValue());
    }
    assertEqualIgnoringOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testValuesInOrder() {
    List<V> expected = Lists.newArrayList();
    for (Entry<K, V> entry : getOrderedElements()) {
      expected.add(entry.getValue());
    }
    assertEqualInOrder(expected, multimap().values());
  }

        this.bannedPrefix = bannedPrefix;
        this.newPrefix = newPrefix;
        this.problems = problems;
    }

    @Override
    public Object getValue(String expression) {
        Object value = valueSource.getValue(expression);

        if (value != null && expression.startsWith(bannedPrefix)) {
            String msg = "The expression ${" + expression + "} is deprecated.";

    for (int i = 0; i < n; i++) {
      // requireNonNull is safe because the first `n` elements have been filled in.
      Entry<K, V> entry = requireNonNull(entryArray[i]);
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);
      int keyHash = key.hashCode();
      int valueHash = value.hashCode();
      int keyBucket = Hashing.smear(keyHash) & mask;

        return "{" + getUserId() + "}";
    }

    @Override
    public String getUserId() {
        return DocumentUtil.getValue(attributes, "email", String.class);
    }

    public String[] getUserGroups() {
        String[] userGroups = DocumentUtil.getValue(attributes, "groups", String[].class);
        if (userGroups == null) {
            userGroups = getDefaultGroupsAsArray();
        }

    byte result = 0x01;
    for (int i = 0; i < reps; i++) {
      CRC32 checksum = new CRC32();
      checksum.update(testBytes, 0, testBytes.length);
      result = (byte) (result ^ checksum.getValue());
    }
    return result;
  }

  // CRC32C

  @Benchmark
  byte crc32cHashFunction(int reps) {
    return runHashFunction(reps, Hashing.crc32c());
  }

  // Adler32

  @Benchmark

       */
      if (key.equals(candidateKey)) {
        return entry.getValue();
      }
    }
    return null;
  }

  @Override
  public void forEach(BiConsumer<? super K, ? super V> action) {
    checkNotNull(action);
    for (Entry<K, V> entry : entries) {
      action.accept(entry.getKey(), entry.getValue());
    }
  }

  @Override
  public int size() {

      List<Entry<K, V>> builder = new ArrayList<>();
      for (Entry<K, Collection<V>> entry : insertionOrder) {
        for (V v : entry.getValue()) {
          builder.add(mapEntry(entry.getKey(), v));
        }
        map.put(entry.getKey(), entry.getValue());
      }
      Iterable<Entry<K, V>> ordered = multimapGenerator.order(builder);
      LinkedHashMap<K, Collection<V>> orderedMap = new LinkedHashMap<>();

      Gist gist = gistJsonAdapter.fromJson(response.body().source());

      for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) {
        System.out.println(entry.getKey());
        System.out.println(entry.getValue().content);
      }
    }
  }

  static class Gist {
    Map<String, GistFile> files;
  }

  static class GistFile {
    String content;
  }