return inverse;
  }

  @SuppressWarnings("unchecked")
  @Override
  @CheckForNull
  public V get(@CheckForNull Object key) {
    Object result =
        RegularImmutableMap.get(keyHashTable, alternatingKeysAndValues, size, keyOffset, key);
    /*
     * We can't simply cast the result of `RegularImmutableMap.get` to V because of a bug in our

    public int getColumnNumber() {
        return columnNumber;
    }

    public InputSource getSource() {
        return source;
    }

    public InputLocation getLocation(Object key) {
        return locations != null ? locations.get(key) : null;
    }

    public Map<Object, InputLocation> getLocations() {
        return locations;
    }

    /**

.
 | map(select(.unitTests) | .name)
 | to_entries
 | group_by(.key % 10)
 | map({
     name: map(.value) | join(", "),
     tasks: map(.value + ":test") | join(" "),

<%@page pageEncoding="UTF-8" contentType="text/html; charset=UTF-8"%>
<footer role="contentinfo">
	<div class="container text-center">
		<p class="textmuted">
			<la:message key="labels.footer.copyright" />
		</p>
	</div>

  }

  private static final Predicate<String> KEY_PREDICATE =
      new Predicate<String>() {
        @Override
        public boolean apply(String key) {
          return !"badkey".equals(key);
        }
      };

  public void testFilterKeys() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();
    unfiltered.put("foo", 55556);
    unfiltered.put("badkey", 1);

                parentBuilder.getSubjectGenerator()))
        .withFeatures(computeMultimapGetFeatures(parentBuilder.getFeatures()))
        .named(parentBuilder.getName() + ".get[key]")
        .suppressing(parentBuilder.getSuppressedTests())
        .createTestSuite();
  }

  @Override
  TestSuite computeMultimapAsMapGetTestSuite(
      FeatureSpecificTestSuiteBuilder<

				return
			}
			if z.TargetsMap == nil {
				z.TargetsMap = make(map[string]TargetReplicationResyncStatus, zb0002)
			} else if len(z.TargetsMap) > 0 {
				for key := range z.TargetsMap {
					delete(z.TargetsMap, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 TargetReplicationResyncStatus
				za0001, err = dc.ReadString()
				if err != nil {

		return errors.New("log buffer full")
	}
	return nil
}

// SendFromStore - reads the log from store and sends it to kafka.
func (h *Target) SendFromStore(key store.Key) (err error) {
	auditEntry, err := h.store.Get(key)
	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}
	atomic.AddInt64(&h.totalMessages, 1)
	err = h.send(auditEntry)
	if err != nil {

	zb0004, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(localLockMap, zb0004)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	var field []byte
	_ = field
	for zb0004 > 0 {
		zb0004--
		var zb0001 string
		var zb0002 []lockRequesterInfo
		zb0001, err = dc.ReadString()
		if err != nil {

    buildType(AdHocPerformanceScenarioWindows)
    buildType(AdHocPerformanceScenarioMacOS)
    buildType(AdHocPerformanceScenarioMacAppleSilicon)

    params {
        param("env.DEVELOCITY_ACCESS_KEY", "%ge.gradle.org.access.key%")
    }