Map<K, Collection<V>> asMap(Multimap<K, V> multimap) {
    return multimap.asMap();
  }

  /**
   * Returns a multimap view of the specified map. The multimap is backed by the map, so changes to
   * the map are reflected in the multimap, and vice versa. If the map is modified while an
   * iteration over one of the multimap's collection views is in progress (except through the

    /**
     * Displays the profile index page.
     *
     * @return the HTML response
     */
    @Execute
    public HtmlResponse index() {
        return asIndexHtml();
    }

    /**
     * Changes the user password.
     *
     * @param form the profile form
     * @return the HTML response
     */
    @Execute
    public HtmlResponse changePassword(final ProfileForm form) {

There are some background actions that the daemon takes, for example monitoring system memory, watching for file changes or cleaning up caches.
The daemon never runs any user code in the background.

There are several different types of requests, such as a request to run a set of tasks, or to query a tooling model, or to stop.

          "etag": "20000f00f58c508b40720270929bd90e9f07b9bd78fb605e5432a67635fc34722e4fc53b1d5fab9ff8400eb9ded4fba2"
        }
      }
    }
  ]
}
```

### v1.3+ versions

Version 1.3 introduces changes to help with [faster metadata reads and updates](https://blog.min.io/minio-versioning-metadata-deep-dive/)

| Entry           | Encoding                    | Content

        }
        sb.append(comp);
        append = true;
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

  /**
   * Starts with an empty delimiter and changes to the desired value at the end of the iteration.
   */
  @Benchmark
  int assignDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();

			// reset log entries
			atomic.StoreInt64(&dt.entries, 0)
			dt.mutex.Unlock()

			dt.adjust(logCopy)
			return
		}
		dt.mutex.Unlock()
	}
}

// adjust changes the value of the dynamic timeout based on the
// previous results
func (dt *dynamicTimeout) adjust(entries [dynamicTimeoutLogSize]time.Duration) {
	failures, maxDur := 0, time.Duration(0)
	for _, dur := range entries[:] {

And as you would be building the container image again and again during development to check that your code changes are working, there's a lot of accumulated time this would save.

Then, near the end of the `Dockerfile`, we copy all the code. As this is what **changes most frequently**, we put it near the end, because almost always, anything after this step will not be able to use the cache.

```Dockerfile

        }
        sb.append(comp);
        append = true;
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

  /**
   * Starts with an empty delimiter and changes to the desired value at the end of the iteration.
   */
  @Benchmark
  int assignDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();

    assertThat(emptyGraph.nodeOrder()).isEqualTo(ElementOrder.<String>natural());
  }

  /**
   * Tests that the ImmutableValueGraph.Builder doesn't change when the creating ValueGraphBuilder
   * changes.
   */
  @Test
  @SuppressWarnings("CheckReturnValue")
  public void immutableValueGraphBuilder_copiesGraphBuilder() {
    ValueGraphBuilder<String, Object> graphBuilder =

            }
            if (nRead == -1) {
              // we reached EOF
              return new String(buffer, 0, bufIndex);
            }
            // otherwise we got the size wrong.  This can happen if the size changes between when
            // we called sizeIfKnown and when we started reading the file (or I guess if
            // maxCharsPerByte is wrong)
            // Fallback to an incremental approach